News Download - Raspberry Pi Multi Channel Timer

                    GNU GENERAL PUBLIC LICENSE
                       Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

                            Preamble

  The GNU General Public License is a free, copyleft license for
software and other kinds of works.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.  We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors.  You can apply it to
your programs, too.

  When we speak of free software, we are referring to freedom, not
price.  Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.

  To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights.  Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.

  For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received.  You must make sure that they, too, receive
or can get the source code.  And you must show them these terms so they
know their rights.

  Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.

  For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software.  For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.

  Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so.  This is fundamentally incompatible with the aim of
protecting users' freedom to change the software.  The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable.  Therefore, we
have designed this version of the GPL to prohibit the practice for those
products.  If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.

  Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary.  To prevent this, the GPL assures that
patents cannot be used to render the program non-free.

  The precise terms and conditions for copying, distribution and
modification follow.

                       TERMS AND CONDITIONS

  0. Definitions.

  "This License" refers to version 3 of the GNU General Public License.

  "Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.

  "The Program" refers to any copyrightable work licensed under this
License.  Each licensee is addressed as "you".  "Licensees" and
"recipients" may be individuals or organizations.

  To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy.  The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.

  A "covered work" means either the unmodified Program or a work based
on the Program.

  To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy.  Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.

  To "convey" a work means any kind of propagation that enables other
parties to make or receive copies.  Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.

  An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License.  If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.

  1. Source Code.

  The "source code" for a work means the preferred form of the work
for making modifications to it.  "Object code" means any non-source
form of a work.

  A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.

  The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form.  A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.

  The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities.  However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work.  For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.

  The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.

  The Corresponding Source for a work in source code form is that
same work.

  2. Basic Permissions.

  All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met.  This License explicitly affirms your unlimited
permission to run the unmodified Program.  The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work.  This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.

  You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force.  You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright.  Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.

  Conveying under any other circumstances is permitted solely under
the conditions stated below.  Sublicensing is not allowed; section 10
makes it unnecessary.

  3. Protecting Users' Legal Rights From Anti-Circumvention Law.

  No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.

  When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.

  4. Conveying Verbatim Copies.

  You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.

  You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.

  5. Conveying Modified Source Versions.

  You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:

    a) The work must carry prominent notices stating that you modified
    it, and giving a relevant date.

    b) The work must carry prominent notices stating that it is
    released under this License and any conditions added under section
    7.  This requirement modifies the requirement in section 4 to
    "keep intact all notices".

    c) You must license the entire work, as a whole, under this
    License to anyone who comes into possession of a copy.  This
    License will therefore apply, along with any applicable section 7
    additional terms, to the whole of the work, and all its parts,
    regardless of how they are packaged.  This License gives no
    permission to license the work in any other way, but it does not
    invalidate such permission if you have separately received it.

    d) If the work has interactive user interfaces, each must display
    Appropriate Legal Notices; however, if the Program has interactive
    interfaces that do not display Appropriate Legal Notices, your
    work need not make them do so.

  A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit.  Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.

  6. Conveying Non-Source Forms.

  You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:

    a) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by the
    Corresponding Source fixed on a durable physical medium
    customarily used for software interchange.

    b) Convey the object code in, or embodied in, a physical product
    (including a physical distribution medium), accompanied by a
    written offer, valid for at least three years and valid for as
    long as you offer spare parts or customer support for that product
    model, to give anyone who possesses the object code either (1) a
    copy of the Corresponding Source for all the software in the
    product that is covered by this License, on a durable physical
    medium customarily used for software interchange, for a price no
    more than your reasonable cost of physically performing this
    conveying of source, or (2) access to copy the
    Corresponding Source from a network server at no charge.

    c) Convey individual copies of the object code with a copy of the
    written offer to provide the Corresponding Source.  This
    alternative is allowed only occasionally and noncommercially, and
    only if you received the object code with such an offer, in accord
    with subsection 6b.

    d) Convey the object code by offering access from a designated
    place (gratis or for a charge), and offer equivalent access to the
    Corresponding Source in the same way through the same place at no
    further charge.  You need not require recipients to copy the
    Corresponding Source along with the object code.  If the place to
    copy the object code is a network server, the Corresponding Source
    may be on a different server (operated by you or a third party)
    that supports equivalent copying facilities, provided you maintain
    clear directions next to the object code saying where to find the
    Corresponding Source.  Regardless of what server hosts the
    Corresponding Source, you remain obligated to ensure that it is
    available for as long as needed to satisfy these requirements.

    e) Convey the object code using peer-to-peer transmission, provided
    you inform other peers where the object code and Corresponding
    Source of the work are being offered to the general public at no
    charge under subsection 6d.

  A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.

  A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling.  In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage.  For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product.  A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.

  "Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source.  The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.

  If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information.  But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).

  The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed.  Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.

  Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.

  7. Additional Terms.

  "Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law.  If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.

  When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it.  (Additional permissions may be written to require their own
removal in certain cases when you modify the work.)  You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.

  Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:

    a) Disclaiming warranty or limiting liability differently from the
    terms of sections 15 and 16 of this License; or

    b) Requiring preservation of specified reasonable legal notices or
    author attributions in that material or in the Appropriate Legal
    Notices displayed by works containing it; or

    c) Prohibiting misrepresentation of the origin of that material, or
    requiring that modified versions of such material be marked in
    reasonable ways as different from the original version; or

    d) Limiting the use for publicity purposes of names of licensors or
    authors of the material; or

    e) Declining to grant rights under trademark law for use of some
    trade names, trademarks, or service marks; or

    f) Requiring indemnification of licensors and authors of that
    material by anyone who conveys the material (or modified versions of
    it) with contractual assumptions of liability to the recipient, for
    any liability that these contractual assumptions directly impose on
    those licensors and authors.

  All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10.  If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term.  If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.

  If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.

  Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.

  8. Termination.

  You may not propagate or modify a covered work except as expressly
provided under this License.  Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).

  However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.

  Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.

  Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License.  If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.

  9. Acceptance Not Required for Having Copies.

  You are not required to accept this License in order to receive or
run a copy of the Program.  Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance.  However,
nothing other than this License grants you permission to propagate or
modify any covered work.  These actions infringe copyright if you do
not accept this License.  Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.

  10. Automatic Licensing of Downstream Recipients.

  Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License.  You are not responsible
for enforcing compliance by third parties with this License.

  An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations.  If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.

  You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License.  For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.

  11. Patents.

  A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based.  The
work thus licensed is called the contributor's "contributor version".

  A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version.  For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.

  Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.

  In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement).  To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.

  If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients.  "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.

  If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.

  A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License.  You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.

  Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.

  12. No Surrender of Others' Freedom.

  If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License.  If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all.  For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.

  13. Use with the GNU Affero General Public License.

  Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work.  The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.

  14. Revised Versions of this License.

  The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time.  Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.

  Each version is given a distinguishing version number.  If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation.  If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.

  If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.

  Later license versions may give you additional or different
permissions.  However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.

  15. Disclaimer of Warranty.

  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.

  16. Limitation of Liability.

  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.

  17. Interpretation of Sections 15 and 16.

  If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.

                     END OF TERMS AND CONDITIONS

            How to Apply These Terms to Your New Programs

  If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.

  To do so, attach the following notices to the program.  It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.

    <one line to give the program's name and a brief idea of what it does.>
    Copyright (C) <year>  <name of author>

    This program 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.

    This program 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 General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

Also add information on how to contact you by electronic and paper mail.

  If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:

    <program>  Copyright (C) <year>  <name of author>
    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
    This is free software, and you are welcome to redistribute it
    under certain conditions; type `show c' for details.

The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License.  Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".

  You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.

  The GNU General Public License does not permit incorporating your program
into proprietary programs.  If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library.  If this is what you want to do, use the GNU Lesser General
Public License instead of this License.  But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.

About This Lesson
This lesson demonstrates a very simple Python project to set the system time from Python. The application needs to be able to set the system time from the Real Time Clock module, which will be covered in a later lesson. In this early stage it's an opportunity to make sure Python is operating correctly, and learn how to run system commands from Python. The lesson also demonstrates how to write simple functions, to break down the writing of an application into small understandable elements of code.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 1 - Programatically setting the system time.              */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Initial code for a relay timer. This code simply demonstraes setting and */
#/* displaying the Raspberry Pi OS time using Python code.                   */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently, using the following command in a  */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import os
import datetime


#/***************************************************************/
#/* Function to display the system time in a consistant format. */
#/***************************************************************/
def PrintSystemTime():
   Now = datetime.datetime.now()
   print(Now.strftime("CURRENT SYSTEM TIME: %Y-%m-%d %H:%M:%S"))


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
def SetSystemTime(NewTime):
   os.system("date -s '" + NewTime + "' > /dev/null")


#/**************************************************************************/
#/* Main application procedure.                                            */
#/* Currently just a test procedure to demonstrate setting the system time */
#/* and date, and displaying it, several times.                            */
#/**************************************************************************/
SetSystemTime("2012-08-02 15:22:34")
PrintSystemTime()

SetSystemTime("1981-12-25 05:45:30")
PrintSystemTime()

SetSystemTime("2015-06-15 19:35:00")
PrintSystemTime()

This file is the main part of the application, which is run when the application is started. The first line in the file, #!/usr/bin/python, tells the system how to run the source code. So the source code can be run by double clicking on the file in the File Manager or just typing ./PiTimer.py in a Terminal window. The file will need the execution flag set first, to do this the following needs to be typed in a Terminal window: chmod +x PiTimer.py

Many of the lines in a source code file are ignored by the Python interpreter. These are comments which are intended for humans readers only. They help describe what the code is doing and why certain things where done it the way they where. All comment lines start with a # character, all other lines are Python code.

Most computer languages these days come with a framework, a library of functions which can be used over and above the basic language. And additional third party framework libraries can be added to the language at any time. The frameworks are divided into groups of functionality which relate to each other. In Python to tell Python that a particular set of functions are to be used in the application, the import statement is used. In this source code, the libraries os and datetime are used. For this application, the os library provides a function to run Linux system commands from Python and the datetime library provides functions to handle date and time operations.

The framework libraries contain sets of functions which will perform a specific task when called. Writing a program in Python, is achieved by breaking down the task required into much smaller tasks. When this is done the application can be written in manageable stages, each stage can be tested independently to ensure errors are removed from the application. The stages are written as sets of functions and the main part of the application then just calls into the functions as required.

A function is written in Python by first declaring the name of the function and what data is to be passed into the function, as arguments. See the source code in file PiTimer.py the function SetSystemTime is defined as def SetSystemTime(NewTime): functions are defined with the term def and then the function name, in this case SetSystemTime. The data to be passed into the function follows in brackets as a list of arguments separated by commas, in this case just one argument named NewTime. This is the date and time to set the system time to.

Python code is written as indented code. So function definitions are written starting on the hard left, column 1 of the document. The code within the function is indented. The amount it is indented is up to you, I use three space characters to indent each line, what ever size indent you choose, you should keep consistent through all of your code. I recommend indenting with space characters and not tab characters. This is because it is difficult to tell what is a tab character and mixing tabs and spaces will break a program without being visibly obvious. This is one of the major issues with Python, it is space sensitive and can lead to confusion if not strictly adhered to. Function code is not the only time when indents are used. Loop and conditional code is also indented, which provides an easily visible way to read through the code for both the human and the computer.

The main application code at the bottom of PiTimer.py calls into the functions defined at the top of the code, it sets the system time and displays it three times. The Python interpreter is a single parse interpreter, this means that the functions need to be defined in the source code before they are called. If a function is called before it is defined in the source code Python will stop with an error.

Running The Code
In a Terminal window, type the following:
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and later control the Raspberry Pi GPIO pins.

The application will set the system time to three different values and display the system time after each time it has been set. This is to prove Python can set the system time. In later lessons a Real Time Clock module will be used to keep the system time current when the system is powered off. Then the application will make sure the system time has been set correctly when it starts.

About This Lesson
This lesson takes a small step from the previous lesson to describe Object Orientation. The functions are taken and placed into a class.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 2 - Python clesses.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* This code demonstraes moving the code from step 1 into a simple class    */
#/* to demonstrate Python classes, befor moving onto larger Python classes.  */
#/*                                                                          */
#/* The code does the same as in step 1, sets and displays the system time   */
#/* several times in succession.                                             */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently, using the following command in a  */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import SystemTime


#/**************************************************************************/
#/* Main application procedure.                                            */
#/* Currently just a test procedure to demonstrate setting the system time */
#/* and date, and displaying it, several times.                            */
#/**************************************************************************/
ThisSystemTime = SystemTime.SystemTime()

ThisSystemTime.SetSystemTime("2012-08-02 15:22:34")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString())

ThisSystemTime.SetSystemTime("1981-12-25 05:45:30")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString())

ThisSystemTime.SetSystemTime("2015-06-15 19:35:00")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString())

The functions written in lesson 1 have been taken and placed into a class called SystemTime the class is placed in a file called SystemTime.py, this file is described below. In order to use the code in the file SystemTime.py, the line import SystemTime is used in this file. One of the advantages of using object orientation is the ability to create many instances of the class, each instance of the class can have unique values associated with that instance. In this example, the class is very simple and only contains two functions. To create an instance of the class to be used here, the line ThisSystemTime = SystemTime.SystemTime() is used. Now the functions in the class can be called in exactly the same way as in lesson 1, but the call needs to be prefixed with the unique instance name ThisSystemTime, this can be seen in the source code below.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 2 - Python clesses.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The class name in this file is defined using the keyword class, in this file is defined by class SystemTime:. The functions in the class are written in exactly the same way as in lesson one, except they are indented below the class definition line and their first argument must always be self to show they belong to each specific instance of the class. This tells Python that they belong to the class.

Running The Code
In a Terminal window, type the following:
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and later control the Raspberry Pi GPIO pins.

The application will set the system time to three different values and display the system time after each time it has been set. This is to prove Python can set the system time. In later lessons a Real Time Clock module will be used to keep the system time current when the system is powered off. Then the application will make sure the system time has been set correctly when it starts.

About This Lesson
This lesson covers the basics of scheduling date and time events. It allows date and time events to be added and the schedule be displayed.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 3 - Schedule table.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Initial code for a relay timer. This code simply demonstraes setting and */
#/* displaying the Raspberry Pi OS time using Python code.                   */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import datetime
import SystemTime
import Schedule
import ScheduleItem


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/

# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()

# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()


#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString())

#  /***************************************************************************/
# /* Add some sample schedules to demonstrate displaying the schedule table. */
#/***************************************************************************/
# Example turn relay 1 on, on every minute and off every thirty seconds past the minute.
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 0), ScheduleItem.RELAY_ON,
                         datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 30), ScheduleItem.RELAY_OFF,
                         datetime.timedelta(0, 60))

# Example turn relay 2 on, on every 15 seconds past the minute and off every fourty five
# seconds past the minute.
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 15), ScheduleItem.RELAY_ON,
                                              datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 45), ScheduleItem.RELAY_OFF,
                                              datetime.timedelta(0, 60))

# Example toggle relay 3 every 15 seconds.
ThisSchedule.AddSchedule(3, datetime.datetime(2015, 6, 1, 0, 0, 00), ScheduleItem.RELAY_TOGGLE,
                                              datetime.timedelta(0, 15))

#  /***************************************/
# /* Display the current event schedule. */
#/***************************************/
ThisSchedule.DisplaySchedule(ThisSchedule.GetItem(2).GetItemID())

The main application now creates an instance of a Schedule class, this class is described below. The AddSchedule function of the Schedule class is then called five times, to add five different schedules to the system. Finally the DisplaySchedule function of the Schedule class is called to display the current schedules registered with the Schedule class.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 3 - Schedule table.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import ScheduleItem


class Schedule:

   def __init__(self):
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemID):
      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayHeader()

      for ThisScheduleItem in self.ScheduleItems:
         if SelectedItemID == ThisScheduleItem.GetItemID():
            SelectLeftChar = ">"
            SelectRightChar = "<"
         else:
            SelectLeftChar = " "
            SelectRightChar = " "
         ThisScheduleItem.DisplayItem(SelectLeftChar, SelectRightChar)

      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayFooter()


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                                          NewRelayState, NewRepeat))

The Schedule class has a constructor function, which is defined as def __init__(self): this function is not called by the programmer, instead it is called by Python when an instance of the class is created, specifically for the instance being created. This allows the programmer to initialize values associated with that specific instance of the class. Here it defines a place to store schedules self.ScheduleItems = [], this is an array of instances of a ScheduleItem class. Which means it's a place where many ScheduleItems can be stored.

Variables which belong to the class are referred to with a prefix self., this indicates that the variable belongs to and is unique to this specific instance of the class. This is in the same manor for functions, in that if the first argument of a function is self, the function belongs to this specific instance of the class.

The Schedule class provides three functions at this point, AddSchedule to add an additional schedule to the ScheduleItems instance variable, GetItem to retrieve a specific ScheduleItem instance from the ScheduleItems instance variable and DisplaySchedule to display all of the ScheduleItems currently stored.

Arrays are objects, such as classes, so has a set of functions available for use. The AddSchedule function uses the append array object function to add a new instance of a ScheduleItem to the array. A specific ScheduleItem can be retrieved by using the GetItem function.

And a summary of all of the currently stored ScheduleItems can be displayed using the DisplaySchedule function, this also allows a specific item to be highlighted in the list of items displayed.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 3 - Schedule table.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import datetime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/****************************************************************/
#/* When tabulating the results, display a header for the table. */
#/****************************************************************/
   def DisplayHeader(self):
      print("{:=^53}".format(""))
      print("|{:^51}|".format("CURRENT SCHEDULE"))
      print("{:=^53}".format(""))
      print("| {:^5}|{:^19}|{:^5}|{:^17} |".format("Relay", "Next Schedule", "State", "Repeat After"))
      print("|{:-^6}|{:-^19}|{:-^5}|{:-^18}|".format("", "", "", ""))


#/****************************************************************/
#/* When tabulating the results, display a footer for the table. */
#/****************************************************************/
   def DisplayFooter(self):
      print("{:=^53}".format(""))


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar, SelectRightChar):
      print("|{}{:>5}|{:^19}|{:^5}|{:>17}{}|".format(SelectLeftChar, self.RelayNumber,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S"), self.RelayState, str(self.Repeat),
            SelectRightChar))

The ScheduleItem class stores the information related to a single schedule. Instances of this class are created and added to an instance of the Schedule class. This allows each schedule to be manipulated and iterated individually without effecting the other schedules in the system.

At the top of the source file, some constants are defined to represent the possible states of a relay. Constants provide a human readable name for a value used in the application.

The constructor of the class is passed the values for the schedule item at creation. The values of the class can be obtained by calling accessor functions, the only accessor function defined at this time is the GetItemID function. Accessor functions can also set values, for this class no functions are required to set values as the schedule items will not be editable, they will just be created and deleted if required.

There are member functions which display the current item values. A member function DisplayHeader is used at the start of displaying items, to display the value titles. Then DisplayItem is called for each of the instances of the classes to display the values of. And finally DisplayFooter is called to display the bottom of the list of items.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 3 - Schedule table.                                       */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

About This Lesson
This lesson adds a schedule trigger process. The basis for running schedules and rescheduling items when they trigger.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 4 - Schedule functions.                                   */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Filling out the scheduling functions required for the system.            */
#/* Sample code to test the scheduling functions written.                    */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import datetime
import SystemTime
import Schedule
import ScheduleItem


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/

# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()

# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()


#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString())

#  /***************************************************************************/
# /* Add some sample schedules to demonstrate displaying the schedule table. */
#/***************************************************************************/
# Example turn relay 1 on, on every minute and off every thirty seconds past the minute.
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 0),
                         ScheduleItem.RELAY_ON, datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 30),
                         ScheduleItem.RELAY_OFF, datetime.timedelta(0, 60))

# Example turn relay 2 on, on every 15 seconds past the minute and off every fourty
# five seconds past the minute.
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 15),
                         ScheduleItem.RELAY_ON, datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 45),
                         ScheduleItem.RELAY_OFF, datetime.timedelta(0, 60))

# Example toggle relay 3 every 15 seconds.
ThisSchedule.AddSchedule(3, datetime.datetime(2015, 6, 1, 0, 0, 00),
                         ScheduleItem.RELAY_TOGGLE, datetime.timedelta(0, 15))

#  /***************************************/
# /* Display the current event schedule. */
#/***************************************/
ThisSchedule.DisplaySchedule(ThisSchedule.GetItem(2).GetItemID())

#  /*************************************/
# /* Delete an item from the schedule. */
#/*************************************/
ThisSchedule.DelSchedule(ThisSchedule.GetItem(2).GetItemID())

#  /***************************************/
# /* Display the current event schedule. */
#/***************************************/
print("DELETE ITEM: 2")
ThisSchedule.DisplaySchedule(0)

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
ThisItemID = True
while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
   ThisItemID = ThisSchedule.ScheduleTrigger()
   if ThisItemID:
      print("TRIGGERED RELAY: " + str(ThisSchedule.FindItem(ThisItemID).GetRelayNumber()))
      ThisSchedule.SetNextScheduleDate(ThisItemID)
   else:
      print("NO EVENT TRIGGERED")

#  /***************************************/
# /* Display the current event schedule. */
#/***************************************/
   ThisSchedule.DisplaySchedule(0)

In addition to the previous lesson, a test of the new delete schedule item feature of the Schedule class, has been added.

Most significant, a while loop has been added. Loops allow a process to be repeated a number of times until a condition is met. In this case a while loop, which repeats while schedule items are found to have triggered. Initially the ThisItemID variable is set to true, to force the loop to run at least for one cycle. The loop calls the member function ScheduleTrigger of the Schedule class, which checks to see it any of the schedule items have triggered. If an ID of a schedule item is returned, this schedule item has triggered. The schedule item will be displayed and a call to the Schedule member function SetNextScheduleDate will reschedule the item to it's next schedule date. When a cycle of the loop fails to return a schedule ID, no further schedule items have triggered at this time and the while loop is complete. A summary of the schedule items are displayed and the application finishes.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 4 - Schedule functions.                                   */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemID):
      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayHeader()

      for ThisScheduleItem in self.ScheduleItems:
         if SelectedItemID == ThisScheduleItem.GetItemID():
            SelectLeftChar = ">"
            SelectRightChar = "<"
         else:
            SelectLeftChar = " "
            SelectRightChar = " "
         ThisScheduleItem.DisplayItem(SelectLeftChar, SelectRightChar)

      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayFooter()


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber,
                                NewScheduleDate, NewRelayState, NewRepeat))
      self.SortSchedule()


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()

Each schedule item has a unique ID, which can be used to refer to a specific schedule item. A member function has been added to the Schedule class, in order to find the instance of the ScheduleItem class which a specific ID refers to.

A DelSchedule member function has been added to allow schedule items to be removed.

When an event occurs to a schedule item, such as adding a new schedule item, deleting a schedule item or rescheduling an item. The schedule items are restored into the order of the most recent to next trigger to longest to next trigger. This allows checks for triggered schedule items to be as simple as checking the expiry date of the first schedule item in the list.

Member function ScheduleTrigger has been added, which simply checks the first schedule item in the list to see if it has triggered. If it has, return it's unique ID

Member function SetNextScheduleDate, which allows the application to reschedule a schedule item to it's next expiry date, once it has processed the triggered schedule item. Unless the schedule item does not have a reschedule date, in which case the schedule item will be deleted.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 4 - Schedule functions.                                   */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False

#/****************************************************************/
#/* When tabulating the results, display a header for the table. */
#/****************************************************************/
   def DisplayHeader(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:=^53}".format(""))
      print("|{:^51}|".format("CURRENT SCHEDULE " + ThisSystemTime.SystemTimeString()))
      print("{:=^53}".format(""))
      print("| {:^5}|{:^19}|{:^5}|{:^17} |".format("Relay", "Next Schedule", "State", "Repeat After"))
      print("|{:-^6}|{:-^19}|{:-^5}|{:-^18}|".format("", "", "", ""))


#/****************************************************************/
#/* When tabulating the results, display a footer for the table. */
#/****************************************************************/
   def DisplayFooter(self):
      print("{:=^53}".format(""))


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar, SelectRightChar):
      print("|{}{:>5}|{:^19}|{:^5}|{:>17}{}|".format(SelectLeftChar, self.RelayNumber,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S"), self.RelayState, str(self.Repeat),
            SelectRightChar))

A few additional accessor member functions for the ScheduleItem class have been added, GetRelayNumber and GetScheduleDate.

SetNextScheduleDate member function has been added, which will automatically take the period of the schedule item and add it to the previous expiry date of the schedule item, to ensure the schedule item will expire at a consistent period each time it is rescheduled.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 4 - Schedule functions.                                   */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Running The Code
In a Terminal window, type the following:
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and later control the Raspberry Pi GPIO pins.

The application will set the system time ready for when the Real Time Clock module is implemented. It will then add several schedule events and display a summary of the schedule events which have been added. A schedule event will then be deleted and a summary of the schedule events displayed again, showing that the schedule item has been deleted. Finally the application will check for schedule events which have triggered, displaying and rescheduling the triggered events, until all pending events have been triggered. And then display a summary of the updated schedule events.

About This Lesson
A significant leap forward is taken in this lesson. User interactions are added to provide an application which runs until the user indicates to the application it is to finish. The concept of hardware is added with a Relays class, at this point conceptually controlling virtual relay devices, which in later lessons will become actual physical switching devices.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 5 - Relay functions.                                      */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Make a main loop for the application which checks for expired schedule   */
#/* events every second. When found update the state of the specific relay   */
#/* and display a summary of all relay states.                               */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays


#/**************************/
#/* Application constants. */
#/**************************/
MAX_RELAYS = 3
KEY_ESC = 27
MAIN_LOOP_PERIOD = 250
CHECK_SCHEDULE_COUNT = 4


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/

# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()

# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()

# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)
window.erase()
window.refresh()

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")
print("CURRENT SYSTEM TIME: " + ThisSystemTime.SystemTimeString() + "\r")

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS + 1):
   ThisRelays.AddRelay(Count, Relays.RELAY_OFF)

#  /***************************************************************************/
# /* Add some sample schedules to demonstrate displaying the schedule table. */
#/***************************************************************************/
# Example turn relay 1 on, on every minute and off every thirty seconds past the minute.
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 0),
                         ScheduleItem.RELAY_ON, datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(1, datetime.datetime(2015, 6, 1, 0, 0, 30),
                         ScheduleItem.RELAY_OFF, datetime.timedelta(0, 60))

# Example turn relay 2 on, on every 15 seconds past the minute and off every fourty
# five seconds past the minute.
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 15),
                         ScheduleItem.RELAY_ON, datetime.timedelta(0, 60))
ThisSchedule.AddSchedule(2, datetime.datetime(2015, 6, 1, 0, 0, 45),
                         ScheduleItem.RELAY_OFF, datetime.timedelta(0, 60))

# Example toggle relay 3 every 15 seconds.
ThisSchedule.AddSchedule(3, datetime.datetime(2015, 6, 1, 0, 0, 00),
                         ScheduleItem.RELAY_TOGGLE, datetime.timedelta(0, 15))

#  /***************************************/
# /* Display the current event schedule. */
#/***************************************/
ThisSchedule.DisplaySchedule(0)

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /****************************************/
# /* Process the main loop once a second. */
#/****************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

            print("TRIGGERED RELAY: " + str(ThisRelayNumber) + " ACTION: " + str(ThisRelayAction) + "\r")

#  /*************************************/
# /* Display the current relay states. */
#/*************************************/
            ThisRelays.DisplayRelayStates()

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

Application constants have been added to the top of the source code file. Specifying constants in this way allows values to be altered if required in a single easy to find place. It also makes reading the code easier for humans as numeric values read as descriptive words within the source code. The constants include MAX_RELAYS, the number of physical switching devices the application will support. This value will be increased in later lessons, currently it is set low for testing purposes. KEY_ESC the key code which will detect when the ESC key is pressed on the keyboard. MAIN_LOOP_PERIOD the number of milliseconds which the main application loop will wait between execution loops. This is used to allow the CPU to rest when the application is not doing anything. CHECK_SCHEDULE_COUNT this is the number of times the application loop will run before the schedule items are checked for expiry. These values allow the application to check for user key presses four times every second, and the schedule expiry to be checked once a second.

An instance of the Relays class is created to be able to keep track of each of the statuses of the physical switching devices in the system.

A number of lines of code have been added to allow key presses to be captured from the system. These lines allow a key press value to be read without halting the system and waiting for a key press. If no key is pressed, a value of 0 will be read.

The relay states are all set to an initial value of RELAY_OFF, so when the application starts, it starts from a predictable state.

The main application loop continues until an exit flag is set. This allows the application to be exited for many reasons by simply setting the exit flag. Currently if the keycode read by reading the keyboard is the ESC key, is the only event which sets the exit flag.

The application will sleep for 1/4 of a second every cycle of the main application loop, on each fourth loop, the schedule items will be checked for expiry. When a schedule item has expired, the associated relay state is updated as required.

Before the application exits, the keyboard reading process is reset to it's usual state. If this is not done, for example if Ctrl+C is pressed, or the application aborts with an error, the terminal window will behave strangely. If this occurs, close the terminal window and open a new terminal window before continuing.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 5 - Relay functions.                                      */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import datetime
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState):
      self.RelayState.append([RelayNumber, RelayState])


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:=^21}".format("") + "\r")
      print("|{:^19}|".format(ThisSystemTime.SystemTimeString()) + "\r")
      print("{:=^21}".format("") + "\r")
      print("|{:^9}|{:^9}|".format("Relay", "State") + "\r")
      print("|{:-^9}|{:-^9}|".format("", "") + "\r")

      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            print("|{:>9}|{:^9}|".format(ThisRelayState[0], ThisRelayState[1]) + "\r")

      print("{:=^21}".format("") + "\r")
         

#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Relays class keeps track of the current state of the physical switching devices. The devices have only two states, defined in constants at the top of the file, RELAY_OFF and RELAY_ON. The states are stored in a simple array of values RelayState which is declared in the constructor.

The class has three accessor member functions, GetRelayState to retrieve the state of the specified relay. SetRelayState to set the state of the specified relay to the specified value. ToggleRelayState set the relay state of the specified relay to the opposite state to it's current state.

The remaining member functions are AddRelay to add an additional relay to track the status of, this will be done at the application start up. And DisplayRelayStates to display a summary of all current relay states.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 5 - Relay functions.                                      */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemID):
      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayHeader()

      for ThisScheduleItem in self.ScheduleItems:
         if SelectedItemID == ThisScheduleItem.GetItemID():
            SelectLeftChar = ">"
            SelectRightChar = "<"
         else:
            SelectLeftChar = " "
            SelectRightChar = " "
         ThisScheduleItem.DisplayItem(SelectLeftChar, SelectRightChar)

      if len(self.ScheduleItems):
         self.ScheduleItems[0].DisplayFooter()


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()

The Schedule class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 5 - Relay functions.                                      */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/****************************************************************/
#/* When tabulating the results, display a header for the table. */
#/****************************************************************/
   def DisplayHeader(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:=^53}".format("") + "\r")
      print("|{:^51}|".format("CURRENT SCHEDULE " + ThisSystemTime.SystemTimeString()) + "\r")
      print("{:=^53}".format("") + "\r")
      print("| {:^5}|{:^19}|{:^5}|{:^17} |".format("Relay", "Next Schedule", "State",
            "Repeat After") + "\r")
      print("|{:-^6}|{:-^19}|{:-^5}|{:-^18}|".format("", "", "", "") + "\r")


#/****************************************************************/
#/* When tabulating the results, display a footer for the table. */
#/****************************************************************/
   def DisplayFooter(self):
      print("{:=^53}".format("") + "\r")


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar, SelectRightChar):
      print("|{}{:>5}|{:^19}|{:^5}|{:>17}{}|".format(SelectLeftChar, self.RelayNumber,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S"), self.RelayState, str(self.Repeat),
            SelectRightChar) + "\r")

The ScheduleItem class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 5 - Relay functions.                                      */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Running The Code
In a Terminal window, type the following:
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

The application will set the system time ready for when the Real Time Clock module is implemented. It will then add several schedule events and display a summary of the schedule events which have been added. Every second the application will check for schedule events which have triggered and change the state of the relay associated with that schedule item appropriately. A summary of the updated relay states is displayed. One of the schedule items is set to trigger every 15 seconds, so wait 15 seconds to see the event trigger. This process will continue until the user presses the ESC key on the keyboard.

About This Lesson
In this lesson a class is added to handle user interactions and the user interface state machine. The user interface state machine allows a key press to be read from the user and be passed to the appropriate code to handle the key press. The user interface initially displays a menu of options and accepts a key press. The key press indicates the menu item selected, then the key presses are passed to the appropriate code to handle the menu item function, until control is passed back to the main menu again.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Handle user interface and interactions in a state machine class.         */
#/* Reorganise display in preparationfor a 20 x 4 LCD matrix.                */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
MAX_RELAYS = 20
KEY_ESC = 27
MAIN_LOOP_PERIOD = 250
CHECK_SCHEDULE_COUNT = 4


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/

# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()

# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()

# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisSchedule, ThisRelays)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS + 1):
   ThisRelays.AddRelay(Count, Relays.RELAY_OFF)

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
   if ThisKey != -1:
      ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /****************************************/
# /* Process the main loop once a second. */
#/****************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

The application will set the system time ready for when the Real Time Clock module is implemented. It creates instances of classes it requires and then enters the main application loop. In the main application loop four times a second the keyboard is checked for a key press. If a key has been pressed, it is passed to the UserInterface class instance to handle in it's current state. After the user interface, if the key pressed was the ESC key, the application will flag to exit the main loop. The main loop will also check for expired schedule items, and process them, once a second.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState):
      self.RelayState.append([RelayNumber, RelayState])


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:>20}".format(ThisSystemTime.SystemTimeString()) + "\r")
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      print(Line1 + "\r")
      print(Line2 + "\r")
      print(Line3 + "\r")


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Relays class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(SelectLeftChar)
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber,
                                NewScheduleDate, NewRelayState, NewRepeat))
      self.SortSchedule()


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()

The Schedule class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      print("{}{:^19}".format(SelectLeftChar,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")) + "\r")
      print("{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar, self.RelayNumber,
            self.RelayState, str(Days), str(Hours), str(Minutes), str(Seconds)) + "\r")

The ScheduleItem class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 6 - User interactions.                                    */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_MAIN_MENU = 0
STATE_ADD_SCHEDULE = 1
STATE_DEL_SCHEDULE = 2
STATE_RELAY_STATES = 3
STATE_SCHEDULE = 4
STATE_SET_SYSTEM_TIME = 5
STATE_SHUTDOWN = 6

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display the initial user interface, the main menu.
      self.SetInterfaceState(STATE_MAIN_MENU)


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif KeyCode == 127 and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:>20}".format(self.ThisSystemTime.SystemTimeString()) + "\r")
      print("{:^20}".format("1 Add     4 Schedule") + "\r")
      print("{:^20}".format("2 Delete  5 Set Time") + "\r")
      print("{:^20}".format("3 Relays  6 Shutdown") + "\r")
      self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      self.ThisRelays.DisplayRelayStates()
      self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("ADD SCHEDULE") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r\nPeriod ### ##:##:##\r\nRelay ##    State #\r",
      self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                            self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32]) 
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                    datetime.datetime(string.atoi(UserInput[0:4]),
                    string.atoi(UserInput[5:7]), string.atoi(UserInput[8:10]),
                    string.atoi(UserInput[11:13]), string.atoi(UserInput[14:16]),
                    string.atoi(UserInput[17:19])), RelayState,
                    datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               print("")

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.Mode == MODE_STANDARD:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self.SelectPos, 1)
         else:
            print("{:^20}".format("Empty") + "\r")
      elif self.Mode == MODE_CONFIRM:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         print("{:^20}".format("ARE YOU SURE?") + "\r")
         print("{:^20}".format("(4=N, 6=Y)") + "\r")
      self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif ((KeyCode == ord("0") or KeyCode == ord("7")
            or KeyCode == ord("8") or KeyCode == ord("9"))
            and self.SelectPos < self.ThisSchedule.GetItemCount() - 1):
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10:
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127:
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self.SelectPos, 2)
      else:
         print("\r")
         print("{:^20}".format("Empty") + "\r")
      self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
         or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("SET SYSTEM TIME") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##",
                         self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                              self.InputBuffer))
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

The UserInterface class is a state machine, it keeps track of the current state of the application from the user's point of view. Each time a key press is passed to an instance of the class, the class knows what it did last, so it can pass the key press to the appropriate piece of code to be processed. At the top of the class constants representing the states of the class are defined. Also constants defining sub states are defined, so within a state, several sub-states can be handled. In this class the sub states are MODE_STANDARD and MODE_CONFIRM, which allows an interface state to be it's normal state, or a state where the user is being asked to confirm their action.

In the constructor of the class, the class instance variables are initialized as usual, one of the variables is the current state. This is set to STATE_MAIN_MENU, and it is done within a call to the class member function SetInterfaceState. This means after creating a new instance of the class, the first state will be to display the application menu.

Each user interface is handled in two functions, a function to handle key presses, and a function to handle displaying the user interface. Member function KeyPress receives the key press from the main application loop and passes it to the appropriate function depending on the state member variable InterfaceState. Similarly, when the display needs to be updated, the member function DisplayRefresh is called and passes it to the appropriate function depending on the state member variable InterfaceState.

When the user interface state needs to change, for example when the user selects an option from the main application menu, or when the application needs to return to the main menu, the member function SetInterfaceState is called. This function first ensures any member variables shared between states are reset, and then sets the InterfaceState to the new state and updates the display.

When in a user interface state, say setting the system time, the application needs to read a series of key presses from the user as a date and time. As only one key gets passed from the main application loop at any time, the user interface needs to keep track of the key presses which have been pressed so far. This is done in member variable InputBuffer, this is a string of characters read from the keyboard. This keeps a history of the keys pressed, but it is not appropriate to display directly to the user. So this string can be passed to the member function GetMaskedInput, which takes a mask string and places the input string into the mask string where ever a # character exists or a space character when there are no more input characters to place. So for the system date and time the mask ####-##-## ##:##:## is used. There are additional keys which can be pressed, which are not displayable but have a function, such as a delete key. The member function KeyMaskedInput allows keys to be filtered at input time if they are being applied to a mask, which means a delete key press will delete the last key press read.

For the main menu user interface, the display function simply displays the main menu and the key function depending on which key has been pressed, sets the user interface state to the appropriate value, unless it is menu option 6, which is to exit the application. In this case the key press is converted to an ESC key, which will exit the application when it is passed back to the main application loop.

For the display relay status user interface, the display function calls the member function DisplayRelayStates of the Relays class instance, to display the detail. The key function only looks for the return key being pressed, and then changes the user interface state to display the main menu again.

For the add schedule user interface, the display function uses the GetMaskedInput member function to format three lines of the display. On the first of the lines it takes the value in the input key buffer and formats it as a date and time, the next line takes additional characters from the input key buffer and displays them as the schedule period, then on the third line displays the relay number and relay state. The key function adds the key press to the key input buffer, then checks to see if the key press was the return key. If the key press was the return key and the number of key presses in the input buffer is full, the input buffer is converted to the numeric values required for passing to the member function AddSchedule of the Schedule class instance, then the member function is called with the values. The application state will then be set to display the main menu again.

For the delete schedule user interface, the display function has two sub statuses, one to select the schedule to delete and the other to ask the user to confirm the deletion. To select the schedule to delete the DisplaySchedule member function of the Schedule class instance is called to display a scroll-able list of the current schedules and allows the currently selected item to be highlighted. To confirm the deletion a confirmation prompt is displayed. The key function moves the selection up if 1, 2 or 3 is pressed and moves the selection down if 7, 8, 9 or 0 is pressed. If return is pressed, the sub state is changed to confirmation, if delete key is pressed the state is changed to main menu. In the confirmation state, when key 4 is pressed the state is changed to main menu, or if key 6 is pressed, the selected item is deleted and the state is changed to main menu.

The display schedule user interface, does the same as the delete schedule user interface, listing the schedule items, except does not provide the option to delete the selected item.

For the set system time user interface, the display function displays the input key buffer using a masked input string ####-##-## ##:##:##. The key function populates the masked input as a date and time. When the return key is pressed, the input key buffer is converted to date and time values which are passed to the SetSystemTime member function of the SystemTime class instance. Then sets the status to main menu.

Running The Code
In a Terminal window, type the following:
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

The application will display a main menu of options. An option can be selected by pressing the option number on the keyboard. The return key is used after entering values. If the ESC key is pressed, the application will exit. The options available are: 1 Add Schedule Item, 2 Delete Schedule Item, 3 Display Current Relay Statuses, 4 Display Current Schedule Items, 5 Set System Time, 6 Shutdown Application.

About This Lesson
At this point schedule items can be added, and deleted from the current schedule items. But when the application is closed, all of the current schedule items are forgotten. So after reopening the application, there are no current schedule items. To resolve this issue, this lesson saves the current schedule items at key events in the application use, and reloads the current schedule items when the application is reopened. So the application can resume where it last left off.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Save and load application state after schedule updates, so the           */
#/* applicaion and resume where it left off after an application restart or  */
#/* system restart, or system crash/hang.                                    */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
MAX_RELAYS = 20
KEY_ESC = 27
MAIN_LOOP_PERIOD = 250
CHECK_SCHEDULE_COUNT = 4


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/
# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()
# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()
# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisSchedule, ThisRelays)
time.sleep(1)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS + 1):
   ThisRelays.AddRelay(Count, Relays.RELAY_OFF)

#  /*********************************************************/
# /* Load schedule items from previous run of application. */
#/*********************************************************/
ThisSchedule.Load()

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
   if ThisKey != -1:
      ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /********************************************/
# /* Process the schedule loop once a second. */
#/********************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*****************************************/
# /* Save application state before ending. */
#/*****************************************/
ThisSchedule.Save(True)

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

In the main application source code, there are two additions. After the application initialization code is complete, but before the main application loop, there is a call to a new member function Load of the Schedule class instance. This will load all of the schedule items from a file which was saved when the application was last running. Then after the main application loop, just before the application ends, a call to the new member function Save of the Schedule class instance saves all of the current schedule items to a file, so they can be reloaded when the application next starts.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState):
      self.RelayState.append([RelayNumber, RelayState])


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:>20}".format(ThisSystemTime.SystemTimeString()) + "\r")
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      print(Line1 + "\r")
      print(Line2 + "\r")
      print(Line3 + "\r")


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Relays class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Period between saving schedules to prevent exceesive saving.
      self.SavePeriod = datetime.timedelta(0, 300)
      self.SaveDateTime = datetime.datetime.now()
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(SelectLeftChar)
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()
      self.Save(True)


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()
      self.Save(True)


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()
      self.Save(False)


#/************************************************************************/
#/* Save all schedule items to a file, so they can be reloaded when the  */
#/* application next starts and continue where the application left off. */
#/************************************************************************/
   def Save(self, Force):
      Now = datetime.datetime.now()
      if Force or Now > self.SaveDateTime + self.SavePeriod:
         File = open("Data/Schedule.txt", 'w', 0)
         for ThisScheduleItem in self.ScheduleItems:
            ThisScheduleItem.Save(File)
         File.close()
         self.SaveDateTime = Now


#/******************************************************/
#/* Load all of the schedule items from a file, so the */
#/* application can resume where it last left off.     */
#/******************************************************/
   def Load(self):
      try:
         File = open("Data/Schedule.txt", 'r', 0)
         Result = True
         while Result:
            NewSchedule = ScheduleItem.ScheduleItem(0, 0, 0, 0)
            Result = NewSchedule.Load(File)
            if Result:
               self.ScheduleItems.append(NewSchedule)
         File.close()
         self.SortSchedule()
      except:
         print("")

As the schedules trigger, their next trigger time and date is updated. The power can be removed from the Raspberry Pi at any time without stopping the application. So the schedule items will be saved periodically, every five minutes so an application resume will minimize the effect on the schedule items. The member variables SavePeriod and SaveDateTime are initialized in the constructor of the class, to be used for this purpose.

After a user change to a schedule item, for example adding or deleting an item, the schedule items are saved with a call to the member function Save and value true as the first argument to indicate save now. The first argument is set to false when the schedule items are triggered so a save is only made once every five minutes.

There are two additional member functions Save and Load to save and load all schedule items.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      print("{}{:^19}".format(SelectLeftChar,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")) + "\r")
      print("{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar, self.RelayNumber,
            self.RelayState, str(Days), str(Hours), str(Minutes), str(Seconds)) + "\r")


#/********************************************************/
#/* Save this schedule item to the provided file handle. */
#/********************************************************/
   def Save(self, File):
      File.write(str(self.ItemID) + "," + str(self.RelayNumber) + ","
                 + self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S") + "," + str(self.RelayState)
                 + "," + str(int(self.Repeat.total_seconds())) + "\n")


#/**********************************************************************/
#/* Load the next schedule item details from the provided file handle. */
#/**********************************************************************/
   def Load(self, File):
      ThisLine = File.readline()
      if ThisLine:
         Fields = ThisLine.split(",")
         self.ItemID = string.atoi(Fields[0])
         self.RelayNumber = string.atoi(Fields[1])
         self.RelayState =  string.atoi(Fields[3])

         Period = string.atoi(Fields[4])
         Seconds = operator.mod(Period, 24 * 60 * 60)
         Days = operator.div(Period, 24 * 60 * 60)
         self.Repeat = datetime.timedelta(Days, Seconds)

         DateTime = Fields[2].split(" ")
         ThisDate = DateTime[0].split("-")
         ThisTime = DateTime[1].split(":")
         self.ScheduleDate = datetime.datetime(string.atoi(ThisDate[0]), string.atoi(ThisDate[1]),
                                               string.atoi(ThisDate[2]), string.atoi(ThisTime[0]),
                                               string.atoi(ThisTime[1]), string.atoi(ThisTime[2]))
      return ThisLine != ""

Two member functions are added to the ScheduleItem class, Save and Load. These save and load the current instance schedule item.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 7 - Save/Load application state.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_MAIN_MENU = 0
STATE_ADD_SCHEDULE = 1
STATE_DEL_SCHEDULE = 2
STATE_RELAY_STATES = 3
STATE_SCHEDULE = 4
STATE_SET_SYSTEM_TIME = 5
STATE_SHUTDOWN = 6

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Display application splash screen on initialisation.
      self.DisplaySplash()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display the initial user interface, the main menu.
      self.InterfaceState = STATE_MAIN_MENU


#/***************************************************/
#/* Display a splash screen for application startup */
#/* to show information about this application.     */
#/***************************************************/
   def DisplaySplash(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("PiTimer") + "\r")
      print("{:^20}".format("2015-06-23") + "\r")
      print("{:^20}".format("Version 1.00") + "\r")
      print("{:^20}".format("(C) Jason Birch") + "\r")
      self.ThisWindow.refresh()


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif KeyCode == 127 and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:>20}".format(self.ThisSystemTime.SystemTimeString()) + "\r")
      print("{:^20}".format("1 Add     4 Schedule") + "\r")
      print("{:^20}".format("2 Delete  5 Set Time") + "\r")
      print("{:^20}".format("3 Relays  6 Shutdown") + "\r")
      self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      self.ThisRelays.DisplayRelayStates()
      self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("ADD SCHEDULE") + "\r")
      print(self.GetMaskedInput(
      "####-##-## ##:##:##\r\nPeriod ### ##:##:##\r\nRelay ##    State #\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                            self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32])
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                                             datetime.datetime(string.atoi(UserInput[0:4]),
                                             string.atoi(UserInput[5:7]),
                                             string.atoi(UserInput[8:10]),
                                             string.atoi(UserInput[11:13]),
                                             string.atoi(UserInput[14:16]),
                                             string.atoi(UserInput[17:19])),
                                             RelayState,
                                            datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               print("")
            self.ThisWindow.refresh()

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.Mode == MODE_STANDARD:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self.SelectPos, 1)
         else:
            print("{:^20}".format("Empty") + "\r")
      elif self.Mode == MODE_CONFIRM:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         print("{:^20}".format("ARE YOU SURE?") + "\r")
         print("{:^20}".format("(4=N, 6=Y)") + "\r")
      self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
               or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10:
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127:
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self.SelectPos, 2)
      else:
         print("\r")
         print("{:^20}".format("Empty") + "\r")
      self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
            or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("SET SYSTEM TIME") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##", self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                              self.InputBuffer))
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

The UserInterface class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Running The Code
A directory called Data is required to save files into.
In a Terminal window, type the following:
mkdir Data
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

The application display a main menu of options. Add a few schedules, then shutdown the application. Reopen the application and the previously created schedules should still exist.

About This Lesson
This lesson updates the Relays class, to add Raspberry Pi GPIO hardware support. This will allow transistors, relays and other switching devices to be triggered from the application.

NOTE: When using a relay from GPIO, always use a transistor to operate the relay as relays are too power hungry to connect directly to a GPIO pin. Connecting a relay directly to a GPIO pin is very likely to permanently damage the Raspberry Pi.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Implement the Raspberry Pi GPIO interface to control physical hardware.  */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
GPIO_PINS = [ 5, 6, 12, 13, 14, 15, 16, 18, 19, 20, 21, 23, 24, 25, 26, 0, 0, 0, 0, 0 ]
MAX_RELAYS = 20
KEY_ESC = 27
MAIN_LOOP_PERIOD = 250
CHECK_SCHEDULE_COUNT = 4


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/
# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()
# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()
# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisSchedule, ThisRelays)
time.sleep(1)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
ThisSystemTime.SetSystemTime("2015-06-18 19:40:00")

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS):
   if len(GPIO_PINS) > Count and GPIO_PINS[Count]:
      ThisRelays.AddRelay(Count + 1, Relays.RELAY_OFF, GPIO_PINS[Count])

#  /*********************************************************/
# /* Load schedule items from previous run of application. */
#/*********************************************************/
ThisSchedule.Load()

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
   if ThisKey != -1:
      ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /********************************************/
# /* Process the schedule loop once a second. */
#/********************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*****************************************/
# /* Save application state before ending. */
#/*****************************************/
ThisSchedule.Save(True)

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

#  /*********************************************/
# /* Close Raspberry Pi GPIO before finishing. */
#/*********************************************/
ThisRelays.CloseGPIO()

The GPIO pins for the relays are defined at the top of the main application. When GPIO pins on the Raspberry Pi are required for other purposes they can be removed from the definition here so they are no longer used. Some versions of the Raspberry Pi have additional GPIO pins available, they can be simply added here to allow them to be used by this application.

An instance of the Relays class is created for use.

Before the main application loop, all of the GPIO pins being used for the relays are configured as outputs.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import RPi.GPIO
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []

# Configure Raspberry Pi GPIO interfaces.
      RPi.GPIO.setmode(RPi.GPIO.BCM)


#/*************************************************/
#/* Close Raspberry Pi GPIO use before finishing. */
#/*************************************************/
   def CloseGPIO(self):
      RPi.GPIO.cleanup()


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState, RelayPin):
      self.RelayState.append([RelayNumber, RelayState, RelayPin])
      if RelayPin:
         RPi.GPIO.setup(RelayPin, RPi.GPIO.OUT, initial=RelayState)


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:>20}".format(ThisSystemTime.SystemTimeString()) + "\r")
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      print(Line1 + "\r")
      print(Line2 + "\r")
      print(Line3 + "\r")


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The RPi.GPIO framework is imported at the top of the class file. This framework allows the state of the GPIO pins on the Raspberry Pi to be modified programatically. In the constructor the GPIO function setmode is called to tell the framework that the GPIO pins will be referred to as GPIO numbers. A member function CloseGPIO is also added so the application can call this member function at the end of execution to tidy up the GPIO framework before exiting.

The member function AddRelay has had a line added to configure the required GPIO pins as output pins via the framework function setup. The member function SetRelayState has had a line added to set the output state of a GPIO pin via the framework function output. The member function ToggleRelayState has had a line added to set the output state of a GPIO pin via the framework function output.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Period between saving schedules to prevent exceesive saving.
      self.SavePeriod = datetime.timedelta(0, 300)
      self.SaveDateTime = datetime.datetime.now()
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(SelectLeftChar)
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()
      self.Save(True)


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()
      self.Save(True)


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()
      self.Save(False)


#/************************************************************************/
#/* Save all schedule items to a file, so they can be reloaded when the  */
#/* application next starts and continue where the application left off. */
#/************************************************************************/
   def Save(self, Force):
      Now = datetime.datetime.now()
      if Force or Now > self.SaveDateTime + self.SavePeriod:
         File = open("Data/Schedule.txt", 'w', 0)
         for ThisScheduleItem in self.ScheduleItems:
            ThisScheduleItem.Save(File)
         File.close()
         self.SaveDateTime = Now


#/******************************************************/
#/* Load all of the schedule items from a file, so the */
#/* application can resume where it last left off.     */
#/******************************************************/
   def Load(self):
      try:
         File = open("Data/Schedule.txt", 'r', 0)
         Result = True
         while Result:
            NewSchedule = ScheduleItem.ScheduleItem(0, 0, 0, 0)
            Result = NewSchedule.Load(File)
            if Result:
               self.ScheduleItems.append(NewSchedule)
         File.close()
         self.SortSchedule()
      except:
         print("")

The Schedule class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      print("{}{:^19}".format(SelectLeftChar,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")) + "\r")
      print("{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar, self.RelayNumber,
            self.RelayState, str(Days), str(Hours), str(Minutes), str(Seconds)) + "\r")


#/********************************************************/
#/* Save this schedule item to the provided file handle. */
#/********************************************************/
   def Save(self, File):
      File.write(str(self.ItemID) + "," + str(self.RelayNumber) + ","
                 + self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S") + "," + str(self.RelayState)
                 + "," + str(int(self.Repeat.total_seconds())) + "\n")


#/**********************************************************************/
#/* Load the next schedule item details from the provided file handle. */
#/**********************************************************************/
   def Load(self, File):
      ThisLine = File.readline()
      if ThisLine:
         Fields = ThisLine.split(",")
         self.ItemID = string.atoi(Fields[0])
         self.RelayNumber = string.atoi(Fields[1])
         self.RelayState =  string.atoi(Fields[3])

         Period = string.atoi(Fields[4])
         Seconds = operator.mod(Period, 24 * 60 * 60)
         Days = operator.div(Period, 24 * 60 * 60)
         self.Repeat = datetime.timedelta(Days, Seconds)

         DateTime = Fields[2].split(" ")
         ThisDate = DateTime[0].split("-")
         ThisTime = DateTime[1].split(":")
         self.ScheduleDate = datetime.datetime(string.atoi(ThisDate[0]), string.atoi(ThisDate[1]),
                             string.atoi(ThisDate[2]), string.atoi(ThisTime[0]),
                             string.atoi(ThisTime[1]), string.atoi(ThisTime[2]))
      return ThisLine != ""

The ScheduleItem class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 8 - Controlling physical relays.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_MAIN_MENU = 0
STATE_ADD_SCHEDULE = 1
STATE_DEL_SCHEDULE = 2
STATE_RELAY_STATES = 3
STATE_SCHEDULE = 4
STATE_SET_SYSTEM_TIME = 5
STATE_SHUTDOWN = 6

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Display application splash screen on initialisation.
      self.DisplaySplash()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display the initial user interface, the main menu.
      self.InterfaceState = STATE_MAIN_MENU


#/***************************************************/
#/* Display a splash screen for application startup */
#/* to show information about this application.     */
#/***************************************************/
   def DisplaySplash(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("PiTimer") + "\r")
      print("{:^20}".format("2015-06-23") + "\r")
      print("{:^20}".format("Version 1.00") + "\r")
      print("{:^20}".format("(C) Jason Birch") + "\r")
      self.ThisWindow.refresh()


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif KeyCode == 127 and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:>20}".format(self.ThisSystemTime.SystemTimeString()) + "\r")
      print("{:^20}".format("1 Add     4 Schedule") + "\r")
      print("{:^20}".format("2 Delete  5 Set Time") + "\r")
      print("{:^20}".format("3 Relays  6 Shutdown") + "\r")
      self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      self.ThisRelays.DisplayRelayStates()
      self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("ADD SCHEDULE") + "\r")
      print(self.GetMaskedInput(
      "####-##-## ##:##:##\r\nPeriod ### ##:##:##\r\nRelay ##    State #\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                            self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32])
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                                             datetime.datetime(string.atoi(UserInput[0:4]),
                                             string.atoi(UserInput[5:7]),
                                             string.atoi(UserInput[8:10]),
                                             string.atoi(UserInput[11:13]),
                                             string.atoi(UserInput[14:16]),
                                             string.atoi(UserInput[17:19])), RelayState,
                                             datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               print("")
            self.ThisWindow.refresh()

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.Mode == MODE_STANDARD:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self.SelectPos, 1)
         else:
            print("{:^20}".format("Empty") + "\r")
      elif self.Mode == MODE_CONFIRM:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         print("{:^20}".format("ARE YOU SURE?") + "\r")
         print("{:^20}".format("(4=N, 6=Y)") + "\r")
      self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
               or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10:
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127:
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self.SelectPos, 2)
      else:
         print("\r")
         print("{:^20}".format("Empty") + "\r")
      self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif ((KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8") or KeyCode == ord("9"))
            and self.SelectPos < self.ThisSchedule.GetItemCount() - 1):
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("SET SYSTEM TIME") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##", self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# BOOKMARK: THIS IS A PLACEHOLDER FOR WHEN THE CLOCK MODLUE IS IMPLEMENTED.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                              self.InputBuffer))
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

The UserInterface class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Running The Code
A directory called Data is required to save files into.
In a Terminal window, type the following:
mkdir Data
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and later control the Raspberry Pi GPIO pins.

When the program is run and schedule items are triggered, the switch devices on the appropriate GPIO pin should switch appropriately.

About This Lesson
In this lesson, the system time is managed. The RTC module is used to maintain the system time when the Raspberry Pi is turned off. The application menu item 5 can be used to set the system time and RTC module time.

See the project Raspberry Pi Battery Backed Real Time Clock for details on how to build the RTC module for the Raspberry Pi.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Use the RPi Clock Driver from www.newsdownload.co.uk to maintain the     */
#/* system time while the Raspberry Pi is powered off or rebooted.           */
#/* wget http://www.newsdownload.co.uk/downloads/RPiRTCDriver.tar.gz         */
#/* tar -xf RPiRTCDriver.tar.gz                                              */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
GPIO_PINS = [ 5, 6, 12, 13, 14, 15, 16, 18, 19, 20, 21, 23, 24, 25, 26, 0, 0, 0, 0, 0 ]
MAX_RELAYS = 20
KEY_ESC = 27
MAIN_LOOP_PERIOD = 250
CHECK_SCHEDULE_COUNT = 4


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/
# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()
# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()
# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisSchedule, ThisRelays)
time.sleep(1)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
ModuleTime = ThisSystemTime.GetModuleTime()
ThisSystemTime.SetSystemTime(ModuleTime)

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS):
   if len(GPIO_PINS) > Count and GPIO_PINS[Count]:
      ThisRelays.AddRelay(Count + 1, Relays.RELAY_OFF, GPIO_PINS[Count])

#  /*********************************************************/
# /* Load schedule items from previous run of application. */
#/*********************************************************/
ThisSchedule.Load()

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
   if ThisKey != -1:
      ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /********************************************/
# /* Process the schedule loop once a second. */
#/********************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*****************************************/
# /* Save application state before ending. */
#/*****************************************/
ThisSchedule.Save(True)

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

#  /*********************************************/
# /* Close Raspberry Pi GPIO before finishing. */
#/*********************************************/
ThisRelays.CloseGPIO()

Before the main application loop, the GetModuleTime member function of the SystemTime class instance is called to get the current time and date from the RTC module, the SetSystemTime member function is then called to set the system time to the value retrieved from the RTC module.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import RPi.GPIO
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []

# Configure Raspberry Pi GPIO interfaces.
      RPi.GPIO.setmode(RPi.GPIO.BCM)


#/*************************************************/
#/* Close Raspberry Pi GPIO use before finishing. */
#/*************************************************/
   def CloseGPIO(self):
      RPi.GPIO.cleanup()


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState, RelayPin):
      self.RelayState.append([RelayNumber, RelayState, RelayPin])
      if RelayPin:
         RPi.GPIO.setup(RelayPin, RPi.GPIO.OUT, initial=RelayState)


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:>20}".format(ThisSystemTime.SystemTimeString()) + "\r")
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      print(Line1 + "\r")
      print(Line2 + "\r")
      print(Line3 + "\r")


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Relays class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Period between saving schedules to prevent exceesive saving.
      self.SavePeriod = datetime.timedelta(0, 300)
      self.SaveDateTime = datetime.datetime.now()
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(SelectLeftChar)
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()
      self.Save(True)


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()
      self.Save(True)


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()
      self.Save(False)


#/************************************************************************/
#/* Save all schedule items to a file, so they can be reloaded when the  */
#/* application next starts and continue where the application left off. */
#/************************************************************************/
   def Save(self, Force):
      Now = datetime.datetime.now()
      if Force or Now > self.SaveDateTime + self.SavePeriod:
         File = open("Data/Schedule.txt", 'w', 0)
         for ThisScheduleItem in self.ScheduleItems:
            ThisScheduleItem.Save(File)
         File.close()
         self.SaveDateTime = Now


#/******************************************************/
#/* Load all of the schedule items from a file, so the */
#/* application can resume where it last left off.     */
#/******************************************************/
   def Load(self):
      try:
         File = open("Data/Schedule.txt", 'r', 0)
         Result = True
         while Result:
            NewSchedule = ScheduleItem.ScheduleItem(0, 0, 0, 0)
            Result = NewSchedule.Load(File)
            if Result:
               self.ScheduleItems.append(NewSchedule)
         File.close()
         self.SortSchedule()
      except:
         print("")

The Schedule class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      print("{}{:^19}".format(SelectLeftChar,
            self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")) + "\r")
      print("{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar, self.RelayNumber,
            self.RelayState, str(Days), str(Hours), str(Minutes), str(Seconds)) + "\r")


#/********************************************************/
#/* Save this schedule item to the provided file handle. */
#/********************************************************/
   def Save(self, File):
      File.write(str(self.ItemID) + "," + str(self.RelayNumber) + ","
                 + self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S") + "," + str(self.RelayState)
                 + "," + str(int(self.Repeat.total_seconds())) + "\n")


#/**********************************************************************/
#/* Load the next schedule item details from the provided file handle. */
#/**********************************************************************/
   def Load(self, File):
      ThisLine = File.readline()
      if ThisLine:
         Fields = ThisLine.split(",")
         self.ItemID = string.atoi(Fields[0])
         self.RelayNumber = string.atoi(Fields[1])
         self.RelayState =  string.atoi(Fields[3])

         Period = string.atoi(Fields[4])
         Seconds = operator.mod(Period, 24 * 60 * 60)
         Days = operator.div(Period, 24 * 60 * 60)
         self.Repeat = datetime.timedelta(Days, Seconds)

         DateTime = Fields[2].split(" ")
         ThisDate = DateTime[0].split("-")
         ThisTime = DateTime[1].split(":")
         self.ScheduleDate = datetime.datetime(string.atoi(ThisDate[0]), string.atoi(ThisDate[1]),
                                               string.atoi(ThisDate[2]), string.atoi(ThisTime[0]),
                                               string.atoi(ThisTime[1]), string.atoi(ThisTime[2]))
      return ThisLine != ""

The ScheduleItem class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")


#/*****************************************************************/
#/* Initialize the RTC module date and time from the system time. */
#/*****************************************************************/
   def InitModuleTime(self):
	   os.system("cd RPiRTCDriver; sudo ./RPiRTC /I > /dev/null")


#/*************************************************************/
#/* Read the date and time from the RTC module and return it. */
#/*************************************************************/
   def GetModuleTime(self):
      Result = ""
      os.system("cd RPiRTCDriver; sudo ./RPiRTC /G > RESULT.TXT")
      try:
         File = open("RPiRTCDriver/RESULT.TXT", 'r', 0)
         ThisLine = "X"
         while ThisLine != "":
            ThisLine = File.readline()
            if ThisLine[0:4] == "RTC:":
               Result = ThisLine[-20:-1]
         File.close()
      except:
         Result = ""
      return Result

A new member function InitModuleTime has been added to the SystemTime class. This member function runs the RTC module application in Linux to set the RTC time and date from the current system time and date. A GetModuleTime member function has been added, this function runs the RTC module application in Linux to get the date and time from the RTC module. From the results retrieved, it finds the appropriate line and uses it to parse the value required, then returns the parsed value to the calling function.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 9 - Maintaining the system time.                          */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_MAIN_MENU = 0
STATE_ADD_SCHEDULE = 1
STATE_DEL_SCHEDULE = 2
STATE_RELAY_STATES = 3
STATE_SCHEDULE = 4
STATE_SET_SYSTEM_TIME = 5
STATE_SHUTDOWN = 6

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Display application splash screen on initialisation.
      self.DisplaySplash()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display the initial user interface, the main menu.
      self.InterfaceState = STATE_MAIN_MENU


#/***************************************************/
#/* Display a splash screen for application startup */
#/* to show information about this application.     */
#/***************************************************/
   def DisplaySplash(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("PiTimer") + "\r")
      print("{:^20}".format("2015-06-23") + "\r")
      print("{:^20}".format("Version 1.00") + "\r")
      print("{:^20}".format("(C) Jason Birch") + "\r")
      self.ThisWindow.refresh()


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif KeyCode == 127 and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:>20}".format(self.ThisSystemTime.SystemTimeString()) + "\r")
      print("{:^20}".format("1 Add     4 Schedule") + "\r")
      print("{:^20}".format("2 Delete  5 Set Time") + "\r")
      print("{:^20}".format("3 Relays  6 Shutdown") + "\r")
      self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      self.ThisRelays.DisplayRelayStates()
      self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("ADD SCHEDULE") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r\nPeriod ### ##:##:##\r\nRelay ##    State #\r",
                                self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #", self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32])
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                                             datetime.datetime(string.atoi(UserInput[0:4]),
                                             string.atoi(UserInput[5:7]), string.atoi(UserInput[8:10]),
                                             string.atoi(UserInput[11:13]),
                                             string.atoi(UserInput[14:16]),
                                             string.atoi(UserInput[17:19])),
                                             RelayState, datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               print("")
            self.ThisWindow.refresh()

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.Mode == MODE_STANDARD:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self.SelectPos, 1)
         else:
            print("{:^20}".format("Empty") + "\r")
      elif self.Mode == MODE_CONFIRM:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         print("{:^20}".format("ARE YOU SURE?") + "\r")
         print("{:^20}".format("(4=N, 6=Y)") + "\r")
      self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
               or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10:
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127:
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self.SelectPos, 2)
      else:
         print("\r")
         print("{:^20}".format("Empty") + "\r")
      self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif ((KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8") or KeyCode == ord("9"))
            and self.SelectPos < self.ThisSchedule.GetItemCount() - 1):
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10:
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("SET SYSTEM TIME") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##", self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10:
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# Update the system time and the RTC module time to the date and time provided.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                                                  self.InputBuffer))
            self.ThisSystemTime.InitModuleTime()
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

The KeysSetSystemTime member function of the UserInterface class now calls InitModuleTime member function of the SystemTime class to set the RTC module time and date when the user changes it.

Running The Code
The driver module for the RTC module is required.
In a Terminal window, type the following to make it available to this application:
wget http://www.newsdownload.co.uk/downloads/RPiRTCDriver.tar.gz
tar -xf RPiRTCDriver.tar.gz

A directory called Data is required to save files into.
In a Terminal window, type the following:
mkdir Data
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

When the program is run it will set the system time from the RTC module. Use menu item 5 to set the correct system and RTC time. Now reboot the Raspberry Pi, when the application is started, it should set the system time to the correct time from the RTC module.

About This Lesson
This lesson covers the hardware design and software class for a numeric keypad, allowing the project to be run independently of a full size keyboard, the first step to the stand alone design of the project.

Numeric matrix keypads are available as a module from many electronics suppliers. Alternatively individual switches can be used to assemble a custom keypad.

The number of GPIO pins required on the Raspberry Pi to read the key presses is reduced by the configuration of the switches in a matrix of horizontal and vertical wires. So in this case for twelve switches, rather than twelve GPIO pins, only seven are required.

The circuit is simple, a 470R resistor is placed on each GPIO pin, this is to protect the GPIO pin and limit the flow of current when a button is pressed.

The keys on the keypad are read by making the four GPIO rows outputs and three GPIO columns inputs. Each row is made low (0V) individually, while a row is low, the columns are read to detect which keys on that row are being pressed at that time.

There is a reason why the rows are outputs in this case. To reduce the number of GPIO pins being used in project even further, the output pins for the keypad will also be used to control the LCD module at the same time, in the next lesson.

If you wanted to reduce the number of GPIO pins used even further, there is a series of logic ICs known as multiplexers and demultiplexers. A demultiplexer could be used to convert two GPIO pins of a binary value to four individual lines, where only one can be taken low at any time. And on the reading lines a multiplexer could be used to convert individual columns to a binary value. This has not been implemented in this project to keep the project simple.

Keypad Circuit

Keypad.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle reading key codes from a keypad connected to GPIO pins.  */
#/****************************************************************************/


import RPi.GPIO


class Keypad:

   def __init__(self, GpioPins):
# Store GPIO pins used for Keypad.
      self.ThisGpioPins = GpioPins
# Last key code pressed.
      self.LastKeyCode = -1
# Prevent double reads of the same keypress.
      self.DebounceKey = -1
# GPIO matrix to keycode lookup.
      self.KeyCodeLookup = [ ord("1"), ord("2"), ord("3"),
                             ord("4"), ord("5"), ord("6"),
                             ord("7"), ord("8"), ord("9"),
                             ord("*"), ord("0"), ord("#") ]


# Setup the GPIO for a 4 x 3 keypad matrix. 4 output and 3 input,
# as the 4 output can be uesed to drive data to a 20x4 LCD display too.
      for Count in range(0, len(self.ThisGpioPins)):
         if Count < 3:
            RPi.GPIO.setup(self.ThisGpioPins[Count], RPi.GPIO.IN, pull_up_down=RPi.GPIO.PUD_UP)
         else:
            RPi.GPIO.setup(self.ThisGpioPins[Count], RPi.GPIO.OUT, initial=1)


#/************************************/
#/* Scan the keypad for key presses. */
#/************************************/
   def ScanKeypad(self):
# Don't scan the keypad until the last key has been read.
      if self.LastKeyCode == -1:
# Make sure all keypad output lines are high to start.
         for Row in range(3, 7):
            RPi.GPIO.output(self.ThisGpioPins[Row], 1)

# Scan the keypad for key presses, taking the output lines down one at a time.
         KeyCode = -1
         Count = 0
         for Row in range(3, 7):
            RPi.GPIO.output(self.ThisGpioPins[Row], 0)
            for Col in range(0, 3):
               if RPi.GPIO.input(self.ThisGpioPins[Col]) == 0:
                  KeyCode = self.KeyCodeLookup[Count]
               Count = Count + 1
            RPi.GPIO.output(self.ThisGpioPins[Row], 1)
         if KeyCode != self.DebounceKey:
            self.LastKeyCode = KeyCode


#/***********************************************/
#/* Return the keycode of the last key presses. */
#/************************************************/
   def GetKeyCode(self):
      Result =  self.LastKeyCode
      self.DebounceKey = self.LastKeyCode
      self.LastKeyCode = -1
      return Result

The constructor for the keypad class takes the GPIO pins to use as an argument, so the GPIO pins are not fixed in code. It is important when programming to allow values like this to be altered easily without having to search all of the source code to update them.

Member variables are provided to keep track of the last key pressed, and a method of making sure that a key press is not detected twice, know as debouncing. It is important when the user enters information that key presses are not repeated, or the user interactions become unmanageable.

An array of key translation values is defined. When a key is pressed, this is used to convert the read key into the actual key character value.

Finally the constructor configures the first three GPIO pins for the keypad as input and remaining GPIO pins for the keypad as output.

The ScanKeypad member function is called at regular intervals from the main application loop. There are many ways to debounce a key press. Here it is done in software by making sure a detected key press has been requested by the application before allowing another key press to be read from the keypad.

If the keypad is to be scanned the first step is to make sure all output lines are high, as it is critical only one output line is taken low at any time for the keypad to be read correctly. The output lines are taken low one at a time in a for loop. Each iteration of the for loop reads the input of each of the columns using a second for loop. A count is used to keep track of which key is being inspected, this allows the current key to be looked up in the translation table as soon as a key press is detected. A detected key press is stored in the member variable LastKeyCode.

Only one other member function is required GetKeyCode. This allows the last key read from the keypad to be requested by the application, when it is required for processing. After being read the member variable LastKeyCode is cleared to allow the ScanKeypad member function to read the next key being pressed.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Add a class to read from a numeric keypad connected to the GPIO pins.    */
#/* Use the numeric keypad as an additional input to a keyboard.             */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import SystemTime
import Schedule
import ScheduleItem
import Relays
import Keypad
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
GPIO_PINS = [ 5, 6, 12, 13, 14, 15, 16, 18, 19, 20, 21, 23, 24, 25, 26, 0, 0, 0, 0, 0 ]
GPIO_KEYPAD_PINS = [ 11, 7, 8, 9, 10, 22, 27 ]
MAX_RELAYS = 20
KEY_ESC = 27
MAIN_LOOP_PERIOD = 100
CHECK_SCHEDULE_COUNT = 10


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/
# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()
# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()
# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()
#Instance of keypad class to read key presses ona GPIO keypad.
ThisKeypad = Keypad.Keypad(GPIO_KEYPAD_PINS)

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
curses.initscr()
curses.noecho()
window = curses.newwin(80, 25)
window.nodelay(1)
window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisSchedule, ThisRelays)
time.sleep(1)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
ModuleTime = ThisSystemTime.GetModuleTime()
ThisSystemTime.SetSystemTime(ModuleTime)

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS):
   if len(GPIO_PINS) > Count and GPIO_PINS[Count]:
      ThisRelays.AddRelay(Count + 1, Relays.RELAY_OFF, GPIO_PINS[Count])

#  /*********************************************************/
# /* Load schedule items from previous run of application. */
#/*********************************************************/
ThisSchedule.Load()

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*************************/
# /* Get a user key press. */
#/*************************/
   ThisKey = window.getch()

#   /*************************************************/
#  /* If a keyboard key has not been pressed, check */
# /* for a key press on the GPIO numeric keypad.   */
#/*************************************************/
   if ThisKey == -1:
      ThisKeypad.ScanKeypad()
      ThisKey = ThisKeypad.GetKeyCode()

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
   if ThisKey != -1:
      ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
   if ThisKey == KEY_ESC:
      ExitFlag = True

#  /**********************************************/
# /* Process main application loop every 250ms. */
#/**********************************************/
   curses.napms(MAIN_LOOP_PERIOD)

#  /********************************************/
# /* Process the schedule loop once a second. */
#/********************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      CheckScheduleCount = CHECK_SCHEDULE_COUNT

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*****************************************/
# /* Save application state before ending. */
#/*****************************************/
ThisSchedule.Save(True)

#  /*********************/
# /* Exit application. */
#/*********************/
curses.endwin()

#  /*********************************************/
# /* Close Raspberry Pi GPIO before finishing. */
#/*********************************************/
ThisRelays.CloseGPIO()

The GPIO pins to use for the keypad are defined at the top of the main application, this allows the GPIO pins being used for the keypad to be changed easily if the existing allocation are being used by another application.

An instance of the KeyPad class is created and the GPIO pins to use passed to the constructor of the class.

The main application loop still reads from a standard USB keyboard. Now if a key had not been pressed on the keyboard, the keypad is read by calling the member function ScanKeypad and then the member function GetKeyCode. As the KeyPad class converts a key press into a character no additional code is required in the main application, the application should process the keypad presses automatically.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import RPi.GPIO
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []

# Configure Raspberry Pi GPIO interfaces.
      RPi.GPIO.setmode(RPi.GPIO.BCM)


#/*************************************************/
#/* Close Raspberry Pi GPIO use before finishing. */
#/*************************************************/
   def CloseGPIO(self):
      RPi.GPIO.cleanup()


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState, RelayPin):
      self.RelayState.append([RelayNumber, RelayState, RelayPin])
      if RelayPin:
         RPi.GPIO.setup(RelayPin, RPi.GPIO.OUT, initial=RelayState)


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self):
      ThisSystemTime = SystemTime.SystemTime()
      print("{:>20}".format(ThisSystemTime.SystemTimeString()) + "\r")
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      print(Line1 + "\r")
      print(Line2 + "\r")
      print(Line3 + "\r")


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Relays class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Period between saving schedules to prevent exceesive saving.
      self.SavePeriod = datetime.timedelta(0, 300)
      self.SaveDateTime = datetime.datetime.now()
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(SelectLeftChar)
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()
      self.Save(True)


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()
      self.Save(True)


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()
      self.Save(False)


#/************************************************************************/
#/* Save all schedule items to a file, so they can be reloaded when the  */
#/* application next starts and continue where the application left off. */
#/************************************************************************/
   def Save(self, Force):
      Now = datetime.datetime.now()
      if Force or Now > self.SaveDateTime + self.SavePeriod:
         File = open("Data/Schedule.txt", 'w', 0)
         for ThisScheduleItem in self.ScheduleItems:
            ThisScheduleItem.Save(File)
         File.close()
         self.SaveDateTime = Now


#/******************************************************/
#/* Load all of the schedule items from a file, so the */
#/* application can resume where it last left off.     */
#/******************************************************/
   def Load(self):
      try:
         File = open("Data/Schedule.txt", 'r', 0)
         Result = True
         while Result:
            NewSchedule = ScheduleItem.ScheduleItem(0, 0, 0, 0)
            Result = NewSchedule.Load(File)
            if Result:
               self.ScheduleItems.append(NewSchedule)
         File.close()
         self.SortSchedule()
      except:
         print("")

The Schedule class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      print("{}{:^19}".format(SelectLeftChar, self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")) + "\r")
      print("{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar, self.RelayNumber,
            self.RelayState, str(Days), str(Hours), str(Minutes), str(Seconds)) + "\r")


#/********************************************************/
#/* Save this schedule item to the provided file handle. */
#/********************************************************/
   def Save(self, File):
      File.write(str(self.ItemID) + "," + str(self.RelayNumber) + ","
                 + self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S") + "," + str(self.RelayState)
                 + "," + str(int(self.Repeat.total_seconds())) + "\n")


#/**********************************************************************/
#/* Load the next schedule item details from the provided file handle. */
#/**********************************************************************/
   def Load(self, File):
      ThisLine = File.readline()
      if ThisLine:
         Fields = ThisLine.split(",")
         self.ItemID = string.atoi(Fields[0])
         self.RelayNumber = string.atoi(Fields[1])
         self.RelayState =  string.atoi(Fields[3])

         Period = string.atoi(Fields[4])
         Seconds = operator.mod(Period, 24 * 60 * 60)
         Days = operator.div(Period, 24 * 60 * 60)
         self.Repeat = datetime.timedelta(Days, Seconds)

         DateTime = Fields[2].split(" ")
         ThisDate = DateTime[0].split("-")
         ThisTime = DateTime[1].split(":")
         self.ScheduleDate = datetime.datetime(string.atoi(ThisDate[0]), string.atoi(ThisDate[1]),
                                               string.atoi(ThisDate[2]), string.atoi(ThisTime[0]),
                                               string.atoi(ThisTime[1]), string.atoi(ThisTime[2]))
      return ThisLine != ""

The ScheduleItem class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")


#/*****************************************************************/
#/* Initialize the RTC module date and time from the system time. */
#/*****************************************************************/
   def InitModuleTime(self):
	   os.system("cd RPiRTCDriver; sudo ./RPiRTC /I > /dev/null")


#/*************************************************************/
#/* Read the date and time from the RTC module and return it. */
#/*************************************************************/
   def GetModuleTime(self):
      Result = ""
      os.system("cd RPiRTCDriver; sudo ./RPiRTC /G > RESULT.TXT")
      try:
         File = open("RPiRTCDriver/RESULT.TXT", 'r', 0)
         ThisLine = "X"
         while ThisLine != "":
            ThisLine = File.readline()
            if ThisLine[0:4] == "RTC:":
               Result = ThisLine[-20:-1]
         File.close()
      except:
         Result = ""
      return Result

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 10 - Numeric GPIO keypad.                                 */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_MAIN_MENU = 0
STATE_ADD_SCHEDULE = 1
STATE_DEL_SCHEDULE = 2
STATE_RELAY_STATES = 3
STATE_SCHEDULE = 4
STATE_SET_SYSTEM_TIME = 5
STATE_SHUTDOWN = 6

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Display application splash screen on initialisation.
      self.DisplaySplash()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display the initial user interface, the main menu.
      self.InterfaceState = STATE_MAIN_MENU


#/***************************************************/
#/* Display a splash screen for application startup */
#/* to show information about this application.     */
#/***************************************************/
   def DisplaySplash(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("PiTimer") + "\r")
      print("{:^20}".format("2015-06-23") + "\r")
      print("{:^20}".format("Version 1.00") + "\r")
      print("{:^20}".format("(C) Jason Birch") + "\r")
      self.ThisWindow.refresh()


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif (KeyCode == 127 or KeyCode == ord("*")) and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:>20}".format(self.ThisSystemTime.SystemTimeString()) + "\r")
      print("{:^20}".format("1 Add     4 Schedule") + "\r")
      print("{:^20}".format("2 Delete  5 Set Time") + "\r")
      print("{:^20}".format("3 Relays  6 Shutdown") + "\r")
      self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      self.ThisRelays.DisplayRelayStates()
      self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("ADD SCHEDULE") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r\nPeriod ### ##:##:##\r\nRelay ##    State #\r",
                                self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #", self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32])
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                                             datetime.datetime(string.atoi(UserInput[0:4]),
                                             string.atoi(UserInput[5:7]),
                                             string.atoi(UserInput[8:10]),
                                             string.atoi(UserInput[11:13]),
                                             string.atoi(UserInput[14:16]),
                                             string.atoi(UserInput[17:19])), RelayState,
                                             datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               print("")
            self.ThisWindow.refresh()

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.Mode == MODE_STANDARD:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self.SelectPos, 1)
         else:
            print("{:^20}".format("Empty") + "\r")
      elif self.Mode == MODE_CONFIRM:
         print("{:^20}".format("DELETE SCHEDULE") + "\r")
         print("\r")
         print("{:^20}".format("ARE YOU SURE?") + "\r")
         print("{:^20}".format("(4=N, 6=Y)") + "\r")
      self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
               or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10 or KeyCode == ord("#"):
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127 or KeyCode == ord("*"):
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self.SelectPos, 2)
      else:
         print("\r")
         print("{:^20}".format("Empty") + "\r")
      self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif ((KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8") or KeyCode == ord("9"))
            and self.SelectPos < self.ThisSchedule.GetItemCount() - 1):
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10 or KeyCode == ord("#"):
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.ThisWindow.clear()
      self.ThisWindow.refresh()
      print("{:^20}".format("SET SYSTEM TIME") + "\r")
      print(self.GetMaskedInput("####-##-## ##:##:##\r", self.InputBuffer))
      self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##", self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# Update the system time and the RTC module time to the date and time provided.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                              self.InputBuffer))
            self.ThisSystemTime.InitModuleTime()
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

The UserInterface class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

Running The Code
The driver module for the RTC module is required.
In a Terminal window, type the following to make it available to this application:
wget http://www.newsdownload.co.uk/downloads/RPiRTCDriver.tar.gz
tar -xf RPiRTCDriver.tar.gz

A directory called Data is required to save files into.
In a Terminal window, type the following:
mkdir Data
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

The project should now be controllable from a standard keyboard or the numeric keypad.

About This Lesson
This lesson covers the hardware design and software class for a 20 x 4 LCD display, allowing the project to be run stand alone.

The LCD display shares the GPIO pins for data with the GPIO pins used for the keypad. This reduces the number of GPIO pins required for the hardware.

The LCD display has an enable pin, this needs to be used to disable the data pins on the LCD when the keypad is in use. There is a register select pin also, which allows the type of data being sent to be classed as character data or control data. These require an additional two GPIO pins.

The R/W pin must be connected to 0V to make sure the LCD display can only ever be in read mode. The LCD operates on 5V and the Raspberry Pi GPIO operates on 3V3, so the LCD must never be allowed to try and write to the Raspberry Pi.

Pin V0 is contrast control for the LCD. It is connected to the wiper of a variable resistor, which is connected across the supply. This forms a potential divider, a method of producing a variable lower voltage which is less than the supply voltage.

VS is the 0V supply and DD is 5V supply.

Finally the A and K pins are the LED back light for the LCD display. They are connected to 5V and 0V respectively.

With smart programming the LCD and Keypad can be used and they do not interfere with each others operation.

20 x 4 LCD Display
Added To Keypad Circuit

Keypad.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle reading key codes from a keypad connected to GPIO pins.  */
#/****************************************************************************/


import RPi.GPIO


class Keypad:

   def __init__(self, GpioPins):
# Store GPIO pins used for Keypad.
      self.ThisGpioPins = GpioPins
# Debouce keys to prevent accidental key detection.
      self.DebounceKeyCode = -1
# Last key code pressed.
      self.LastKeyCode = -1
# GPIO matrix to keycode lookup.
      self.KeyCodeLookup = [ ord("1"), ord("2"), ord("3"),
                             ord("4"), ord("5"), ord("6"),
                             ord("7"), ord("8"), ord("9"),
                             ord("*"), ord("0"), ord("#") ]


# Setup the GPIO for a 4 x 3 keypad matrix. 4 output and 3 input,
# as the 4 output can be uesed to drive data to a 20x4 LCD display too.
      for Count in range(0, len(self.ThisGpioPins)):
         if Count < 3:
            RPi.GPIO.setup(self.ThisGpioPins[Count], RPi.GPIO.IN, pull_up_down=RPi.GPIO.PUD_UP)
         else:
            RPi.GPIO.setup(self.ThisGpioPins[Count], RPi.GPIO.OUT, initial=1)


#/************************************/
#/* Scan the keypad for key presses. */
#/************************************/
   def ScanKeypad(self):
# Don't scan the keypad until the last key has been read.
      if self.LastKeyCode == -1:
# Make sure all keypad output lines are high to start.
         for Row in range(3, 7):
            RPi.GPIO.output(self.ThisGpioPins[Row], 1)

# Scan the keypad for key presses, taking the output lines down one at a time.
         KeyCode = -1
         Count = 0
         for Row in range(3, 7):
            RPi.GPIO.output(self.ThisGpioPins[Row], 0)
            for Col in range(0, 3):
               if RPi.GPIO.input(self.ThisGpioPins[Col]) == 0:
                  KeyCode = self.KeyCodeLookup[Count]
               Count = Count + 1
            RPi.GPIO.output(self.ThisGpioPins[Row], 1)
         if KeyCode == -1 or KeyCode != self.DebounceKeyCode:
            self.LastKeyCode = KeyCode
            self.DebounceKeyCode = KeyCode


#/***********************************************/
#/* Return the keycode of the last key presses. */
#/************************************************/
   def GetKeyCode(self):
      Result = -1
      Result =  self.LastKeyCode
      self.LastKeyCode = -1
      return Result

The Keypad class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

LCD.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle writing to an LCD module, connected to GPIO pins.        */
#/****************************************************************************/


import operator
import RPi.GPIO


# GPIO array LCD pin indexes.
LCD_RS_PIN = 0
LCD_E_PIN = 1
LCD_D4_PIN = 2
LCD_D5_PIN = 3
LCD_D6_PIN = 4
LCD_D7_PIN = 5
# LCD module start of line addresses.
CURSOR_LINE_POS = [ 0, 64, 20, 84 ]


class LCD:

   def __init__(self, GpioPins):
# Store GPIO pins used for LCD.
      self.ThisGpioPins = GpioPins
# Text line comparison cache.
      self.TextLineCache = [ "", "", "", "" ]
# Data nibble cache, queue data here to go to the LCD display.
      self.NibbleCache = []
# Rememver the state of the E clock pin.
      self.ePinFlag = False
# Configure all GPIO pins to output.
      for Count in range(len(self.ThisGpioPins)):
         RPi.GPIO.setup(self.ThisGpioPins[Count], RPi.GPIO.OUT, initial=0)
# Initialise display 4bit operation.
      self.CacheNibble(int("0010", 2), False)
# Set display lines to 2, which is required for a 4 line display.
      self.CacheByte(int("00101000", 2), False)
# Set display on, cursor off.
      self.CacheByte(int("00001100", 2), False)
# Set display cursor move write after character write.
      self.CacheByte(int("00000110", 2), False)


#/***********************************************************/
#/* Allow other devices to check if the GPIO pins are busy. */
#/* So they can use the same GPIO pins for another purpose. */
#/***********************************************************/
   def IsBusy(self):
      return self.ePinFlag or len(self.NibbleCache)


#/**************************************/
#/* Set clear dispaly and cursor home. */
#/**************************************/
   def Clear(self):
      self.CacheByte(int("00000001", 2), False)


#/********************/
#/* Set cursor home. */
#/********************/
   def Home(self):
      self.CacheByte(int("00000010", 2), False)


#/***********************************************/
#/* Set the cursor position to the LCD address. */
#/***********************************************/
   def SetCursorPos(self, Pos):
      self.CacheByte(int("10000000", 2) + (Pos & int("7F", 16)), False)


#/***************************************************/
#/* Write a line of text to the specified LCD line. */
#/***************************************************/
   def CacheLine(self, LineNumber, Text):
      CursorPos = CURSOR_LINE_POS[LineNumber - 1]
      Count = 0
      SetPos = True
      for Char in Text:
         if (len(self.TextLineCache[LineNumber - 1]) <= Count
            or Char != self.TextLineCache[LineNumber - 1][Count]):
            if SetPos == True:
               SetPos = False
               self.SetCursorPos(CursorPos)
            self.CacheChr(Char)
         else:
            SetPos = True
         CursorPos += 1
         Count += 1
      self.TextLineCache[LineNumber - 1] = Text


#/***********************************************/
#/* Write an ASCII character to the LCD module. */
#/***********************************************/
   def CacheChr(self, Char):
      self.CacheByte(ord(Char), True)


#/*********************************************************************/
#/* Write a byte of data to the specified register of the LCD module. */
#/*********************************************************************/
   def CacheByte(self, Byte, RsFlag):
      HighNibble = operator.div(Byte, 16)
      LowNibble = operator.mod(Byte, 16)
      self.CacheNibble(HighNibble, RsFlag)
      self.CacheNibble(LowNibble, RsFlag)


#/***************************************************************************/
#/* Main application adds data to be sent to the LCD here. The data is sent */
#/* to the LCD when the LCD is ready to process data and does not hold up   */
#/* the main application processing. Bit 0-3 Data, bit 4 RS line.           */
#/***************************************************************************/
   def CacheNibble(self, Nibble, RsFlag):
      if RsFlag:
         Nibble |= int("10000", 2)
      self.NibbleCache.append(Nibble)


#/************************************************************************/
#/* Called from main application loop every 5ms, in order to write data */
#/* to the LCD at a rate slow enough for the LCD to handle.              */
#/************************************************************************/
   def WriteNibble(self):
      if self.ePinFlag:
         self.ePinFlag = False
# Finish clocking the previous data into the LCD module.
         RPi.GPIO.output(self.ThisGpioPins[LCD_E_PIN], 0)
      elif len(self.NibbleCache):
# Start to clock the data into the LCD module.
         self.ePinFlag = True
         RPi.GPIO.output(self.ThisGpioPins[LCD_E_PIN], 1)
# Get the next data to send from the LCD cache.
         Nibble = self.NibbleCache.pop(0)
# Bit 4 of the cache data item is the RS line data.
         if Nibble & int("10000", 2):
            Bit = 1
         else:
            Bit = 0
         RPi.GPIO.output(self.ThisGpioPins[LCD_RS_PIN], Bit)
# Bits 0-3 of the cache data item is the 4 bit data nibble.
         for Count in range(4):
            Bit = operator.mod(Nibble, 2)
            Nibble = operator.div(Nibble, 2)
            RPi.GPIO.output(self.ThisGpioPins[Count + 2], Bit)

The LCD class not only controls the LCD module, but also employs techniques to reduce the amount of communication required with the LCD module. This helps in two ways; As the LCD module is quite slow to communicate with, reducing the amount of communication improves application performance greatly. Also the LCD display refresh rate is quite slow, so only updating the parts of the display which have changed improves the visual effect of the LCD display.

Constants are defined to easily refer to the GPIO pins which are used for the LCD module. The LCD module has four lines, however the cursor positions for the start of each line are not obvious, so an array of constants for the cursor position of the start of each line is defined.

The constructor of the LCD class defines the following member variables, which allow the class to update the display over time, without holding up the main application execution. The TextLineCache member variable stores the current contents of the LCD being displayed. The NibbleCache member variable stores data being queued up to be sent to the LCD module, this prevents the LCD module from holding up the application execution. The ePinFlag member variable is used to control the pin E on the LCD module, the LCD module receives data by setting the data on the data lines and then performing a clock pulse on the E pin. The clock pulse has a minimum time it needs to be active for, so the LCD module has time to read the data. All GPIO pins for the LCD module are output pins, so they are configured for output.

The LCD module can be used in 4bit or 8bit mode. Using 4bit mode reduces the number of GPIO pins required to control the LCD module, but doubles the amount of time it takes to send data to the module. The last thing the constructor of the LCD class does is to send some instructions to the LCD module to initialize it. The first instruction is only four bits of data and it puts the LCD module into 4bit mode, the CacheNibble member function is used to send 4bits of data. The other commands are 8bit commands, so the CacheByte member function is used. The next command sets the display to four line mode, turns the display on and the cursor off, finally make the cursor move right after each character is written to the display.

The IsBusy member function allows the application to check the display is not using the GPIO pins when it wants to read from the keypad.

The Clear member function clears the display and moves the cursor to the first character on the top line.

The Home member function moves the cursor to the first character on the top line.

The SetCursorPos member function allows the cursor to be moved to a specific character on a specific line of the LCD display.

The CacheLine will write a string of characters to a specific line of the LCD display. The characters are placed in the queue to be written to the LCD module while the application is allowed to continue executing.

The CacheChr places a single character on the queue to be displayed at the current cursor position.

The CacheByte member function places an 8bit command on the queue to go to the LCD module. The difference between a character and command being sent to the display, so the RS (Register Select) pin of the LCD module is set to the appropriate level to distinguish between data or command data.

The CacheNibble member function places a 4bit command on the queue to go to the LCD module.

The WriteNibble member function is quite complex, it is a state machine, which means each time it is called it performs a different function depending on the state of member variables of the class. This member function is called periodically from the main application loop. It handles the timing of writing data from the queue to the LCD display. Over a series of calls, it will take a nibble from the queue, placing in on the LCD data lines and setting the RS pin appropriately, and then clocking the data into the LCD module.

PiTimer.py

Click to expand...

#!/usr/bin/python

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Add a class to write to a 20 x 4 character LCD connected to the GPIO     */
#/* pins. Use the LCD as an additional display to a terminal.                */
#/*                                                                          */
#/* The code requires permission in the OS to set the system time so needs   */
#/* to be run as the super user currently using the following command in a   */
#/* terminal window:                                                         */
#/*                                                                          */
#/* sudo python PiTimer.py                                                   */
#/****************************************************************************/


import time
import datetime
import curses
import RPi.GPIO
import SystemTime
import Schedule
import ScheduleItem
import Relays
import Keypad
import LCD
import UserInterface


#/**************************/
#/* Application constants. */
#/**************************/
GPIO_PINS = [ 5, 6, 12, 13, 14, 15, 16, 18, 19, 20, 21, 23, 24, 25, 26, 0, 0, 0, 0, 0 ]
GPIO_KEYPAD_PINS = [ 11, 7, 8, 9, 10, 22, 27 ]
GPIO_LCD_PINS = [ 4, 17, 27, 22, 10, 9 ]
GPIO_LED_PINS = [ 4, 17 ]
LED_RED = 0
LED_GREEN = 1
MAX_RELAYS = 20
KEY_ESC = 27

TERMINAL = False
MAIN_LOOP_PERIOD = 0.1
CHECK_SCHEDULE_COUNT = 10
MAIN_LOOP_PERIOD_LCD = 0.001
CHECK_SCHEDULE_COUNT_LCD = 1000


#/**************************************************************************/
#/* Main application procedure.                                            */
#/**************************************************************************/
# Instance of the system time class to handle system time and clock module.
ThisSystemTime = SystemTime.SystemTime()
# Instance of schedule class to store and process timer schedules.
ThisSchedule = Schedule.Schedule()
# Instnace of relays class to store current relay states.
ThisRelays = Relays.Relays()
#Instance of keypad class to read key presses on a GPIO keypad.
ThisKeypad = Keypad.Keypad(GPIO_KEYPAD_PINS)
#Instance of LCD class to write to a GPIO LCD module.
ThisLCD = LCD.LCD(GPIO_LCD_PINS)

#  /*********************************************************/
# /* Configure the console so key presses can be captured. */
#/*********************************************************/
window = False
if TERMINAL:
   curses.initscr()
   curses.noecho()
   window = curses.newwin(80, 25)
   window.nodelay(1)
   window.timeout(0)

# Instance of user interface class to manage user interactions.
ThisUserInterface = UserInterface.UserInterface(window, ThisLCD, ThisSchedule, ThisRelays)

#   /*******************************************************************/
#  /* Get the time from the timer module, and set the system time to  */
# /* ensure the system time is correct at the start.                 */
#/*******************************************************************/
ModuleTime = ThisSystemTime.GetModuleTime()
ThisSystemTime.SetSystemTime(ModuleTime)

#    /*********************************************************/
#   /* Create an initial state for each realy in the system. */
#  /* Adding an extra item, as item 0 will be ignored so    */
# /* relay numbers start at a more user freindly 1.        */
#/*********************************************************/
for Count in range(MAX_RELAYS):
   if len(GPIO_PINS) > Count and GPIO_PINS[Count]:
      ThisRelays.AddRelay(Count + 1, Relays.RELAY_OFF, GPIO_PINS[Count])

#  /*********************************************************/
# /* Load schedule items from previous run of application. */
#/*********************************************************/
ThisSchedule.Load()

#   /********************************************/
#  /* Main application loop, this continues    */
# /* forever or until the ESC key is pressed. */
#/********************************************/
CheckScheduleCount = CHECK_SCHEDULE_COUNT
ExitFlag = False
while ExitFlag == False:

#  /*******************************************************/
# /* Write from LCD cache onto LCD at a manageable rate. */
#/*******************************************************/
   ThisLCD.WriteNibble()

   if ThisLCD.IsBusy() == False:
#  /*************************/
# /* Get a user key press. */
#/*************************/
      ThisKey = -1
      if TERMINAL:
         ThisKey = window.getch()

#   /*************************************************/
#  /* If a keyboard key has not been pressed, check */
# /* for a key press on the GPIO numeric keypad.   */
#/*************************************************/
      if ThisKey == -1:
         ThisKeypad.ScanKeypad()
         ThisKey = ThisKeypad.GetKeyCode()
#   /*************************************************************/
#  /* Set the red LED indicator off and green LED indicator on. */
# /* Indicators share GPIO pins with LCD and Keypad.           */
#/*************************************************************/
         RPi.GPIO.output(GPIO_LED_PINS[LED_RED], 1)
         RPi.GPIO.output(GPIO_LED_PINS[LED_GREEN], 0)

#  /******************************************************/
# /* Pass user key presses to the user interface class. */
#/******************************************************/
      if ThisKey != -1:
         ThisKey = ThisUserInterface.KeyPress(ThisKey)

#  /**********************************************************/
# /* If the ESC key has been pressed, exit the application. */
#/**********************************************************/
      if ThisKey == KEY_ESC:
         ExitFlag = True

#  /***********************************************/
# /* Process main application loop every period. */
#/***********************************************/
      time.sleep(MAIN_LOOP_PERIOD)
      if CheckScheduleCount > CHECK_SCHEDULE_COUNT:
         CheckScheduleCount = CHECK_SCHEDULE_COUNT
   else:
#  /*********************************************************************/
# /* Process main application loop faster when data is queued for LCD. */
#/*********************************************************************/
      time.sleep(MAIN_LOOP_PERIOD_LCD)
      if CheckScheduleCount > CHECK_SCHEDULE_COUNT_LCD:
         CheckScheduleCount = CHECK_SCHEDULE_COUNT_LCD

#  /********************************************/
# /* Process the schedule loop once a second. */
#/********************************************/
   CheckScheduleCount -= 1
   if CheckScheduleCount <= 0:
      if ThisLCD.IsBusy() == False:
         CheckScheduleCount = CHECK_SCHEDULE_COUNT
      else:
         CheckScheduleCount = CHECK_SCHEDULE_COUNT_LCD

#  /********************************************/
# /* Process all events which have triggered. */
#/********************************************/
      ThisItemID = True
      while ThisItemID:
#     /**************************************************************/
#    /* Check for a scheduled item which has moved into the past.  */
#   /* If an item is found process it and then remove it from the */
#  /* schedule. The item will automatically be rescheduled if    */
# /* required.                                                  */
#/**************************************************************/
         ThisItemID = ThisSchedule.ScheduleTrigger()
         if ThisItemID:
            ThisScheduleItem = ThisSchedule.FindItem(ThisItemID)
            ThisRelayAction = ThisScheduleItem.GetRelayState()
            ThisRelayNumber = ThisScheduleItem.GetRelayNumber()
            if ThisRelayAction == ScheduleItem.RELAY_OFF:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_OFF)
            elif ThisRelayAction == ScheduleItem.RELAY_ON:
               ThisRelays.SetRelayState(ThisRelayNumber, Relays.RELAY_ON)
            else:
               ThisRelays.ToggleRelayState(ThisRelayNumber)
            ThisSchedule.SetNextScheduleDate(ThisItemID)

#  /****************************************************************/
# /* Certain user interface displays need to update every second. */
#/****************************************************************/
      ThisUserInterface.DisplayRefresh()

#  /*****************************************/
# /* Save application state before ending. */
#/*****************************************/
ThisSchedule.Save(True)

#  /*********************/
# /* Exit application. */
#/*********************/
ThisLCD.Clear()
while ThisLCD.IsBusy():
   ThisLCD.WriteNibble()
   time.sleep(MAIN_LOOP_PERIOD_LCD)

if TERMINAL:
   curses.endwin()

#  /*********************************************/
# /* Close Raspberry Pi GPIO before finishing. */
#/*********************************************/
ThisRelays.CloseGPIO()

The GPIO pins used for the LCD display are defined as an array of constants, and constants are defined for the time periods required when sending data to the LCD module. An instance of the LCD class is created. The LCD class instance is passed to the UserInterface constructor so that the UserInterface instance can write data to the LCD module queue.

The LCD member function WriteNibble is called on each iteration of the main application loop, so that when data is waiting to be sent to the LCD module, it is sent as fast as possible.

Before the keypad is read, the LCD instance is checked to make sure it is not currently using the GPIO pins it shares with the keypad.

Some user interface modes require the display to be updated periodically after they have been displayed, such as when they display the current system time. The ThisUserInterface member function DisplayRefresh is called to achieve this.

Relays.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle the current relay states.                                */
#/****************************************************************************/


import operator
import datetime
import RPi.GPIO
import SystemTime


# Constants to define relay state.
RELAY_OFF = 0
RELAY_ON = 1


class Relays:

   def __init__(self):
# Instance storage for relay states.
      self.RelayState = []

# Configure Raspberry Pi GPIO interfaces.
      RPi.GPIO.setmode(RPi.GPIO.BCM)


#/*************************************************/
#/* Close Raspberry Pi GPIO use before finishing. */
#/*************************************************/
   def CloseGPIO(self):
      RPi.GPIO.cleanup()


#/***********************************************************/
#/* Add a relay to the relays supported by the application. */
#/***********************************************************/
   def AddRelay(self, RelayNumber, RelayState, RelayPin):
      self.RelayState.append([RelayNumber, RelayState, RelayPin])
      if RelayPin:
         RPi.GPIO.setup(RelayPin, RPi.GPIO.OUT, initial=RelayState)


#/*******************************************/
#/* Display a table of the current relay    */
#/* states and the date/time at that point. */
#/*******************************************/
   def DisplayRelayStates(self, UserInterface):
      ThisSystemTime = SystemTime.SystemTime()
      UserInterface.PrintLine(1, "{:>20}".format(ThisSystemTime.SystemTimeString()))
      Line1 = ""
      Line2 = ""
      Line3 = ""
      for ThisRelayState in self.RelayState:
         if ThisRelayState[0]:
            RelayDiv = operator.div(ThisRelayState[0], 10)
            RelayMod = operator.mod(ThisRelayState[0], 10)
            if RelayDiv:
               Line1 += str(RelayDiv)
            else:
               Line1 += " "
            Line2 += str(RelayMod)
            Line3 += str(ThisRelayState[1])
      UserInterface.PrintLine(2, "{:<20}".format(Line1))
      UserInterface.PrintLine(3, "{:<20}".format(Line2))
      UserInterface.PrintLine(4, "{:<20}".format(Line3))


#/************************************************/
#/* Get the current state of the specific relay. */
#/************************************************/
   def GetRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         Result = self.RelayState[RelayNumber - 1][1]
      return Result


#/************************************************/
#/* Set the current state of the specific relay. */
#/************************************************/
   def SetRelayState(self, RelayNumber, NewRelayState):
      if RelayNumber - 1 < len(self.RelayState):
         self.RelayState[RelayNumber - 1][1] = NewRelayState
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])


#/***************************************************/
#/* Toggle the current state of the specific relay. */
#/***************************************************/
   def ToggleRelayState(self, RelayNumber):
      Result = False
      if RelayNumber - 1 < len(self.RelayState):
         if self.RelayState[RelayNumber - 1][1] == RELAY_OFF:
            self.RelayState[RelayNumber - 1][1] = RELAY_ON
         else:
            self.RelayState[RelayNumber - 1][1] = RELAY_OFF
         RPi.GPIO.output(self.RelayState[RelayNumber - 1][2], self.RelayState[RelayNumber - 1][1])
         Result = self.RelayState[RelayNumber - 1][1]
      return Result

The Python print statements have been changed to calls to the UserInterface class PrintLine member function, so displayed data is sent to the LCD and console window.

Schedule.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle scheduling events for specific relays. Such as adding,   */
#/* removing, displaying, sorting.                                           */
#/****************************************************************************/


import datetime
import ScheduleItem


#/****************************************************************************/
#/* Function to return the schedule date of a schedule item for when sorting */
#/* the items using the Python list sort feature.                            */
#/****************************************************************************/
def SortGetKey(Object):
   return Object.GetScheduleDate()


class Schedule:

   def __init__(self):
# Period between saving schedules to prevent exceesive saving.
      self.SavePeriod = datetime.timedelta(0, 300)
      self.SaveDateTime = datetime.datetime.now()
# Define an array to store the schedule items in.
      self.ScheduleItems = []


#/*************************************/
#/* Get the number of schedule items. */
#/*************************************/
   def GetItemCount(self):
      return len(self.ScheduleItems)


#/*********************************************/
#/* Get the item at the specific array index. */
#/*********************************************/
   def GetItem(self, ItemIndex):
      if len(self.ScheduleItems) > ItemIndex:
         return self.ScheduleItems[ItemIndex]
      else:
         return False


#/**************************************************/
#/* Find the schedule item with the specificed ID. */
#/**************************************************/
   def FindItem(self, FindItemID):
      ThisItem = False
      for ThisScheduleItem in self.ScheduleItems:
         if ThisScheduleItem.GetItemID() == FindItemID:
            ThisItem = ThisScheduleItem
      return ThisItem


#/*******************************************************/
#/* Function to display the current schedule of events. */
#/* In a tabulated form.                                */
#/*******************************************************/
   def DisplaySchedule(self, UserInterface, LineNumber, SelectedItemIndex, DisplayItemCount):
      Result = False
      for Count in range(0, DisplayItemCount):
         if SelectedItemIndex + Count < len(self.ScheduleItems):
            if Count == 0:
               Result = self.ScheduleItems[SelectedItemIndex + Count].GetItemID()
               SelectLeftChar = ">"
            else:
               SelectLeftChar = " "
            self.ScheduleItems[SelectedItemIndex + Count].DisplayItem(UserInterface,
                                              LineNumber + Count * 2, SelectLeftChar)
         else:
            UserInterface.PrintLine(LineNumber + Count * 2, "{: <20}".format(""))
            UserInterface.PrintLine(LineNumber + 1 +  Count * 2, "{: <20}".format(""))
      return Result


#/*************************************************/
#/* Add a new schedule item to the schedle array. */
#/*************************************************/
   def AddSchedule(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
      self.ScheduleItems.append(ScheduleItem.ScheduleItem(NewRelayNumber, NewScheduleDate,
                                NewRelayState, NewRepeat))
      self.SortSchedule()
      self.Save(True)


#/**************************************************/
#/* Delete a schedule item from the schedle array. */
#/**************************************************/
   def DelSchedule(self, ItemID):
      ThisScheduleItem = self.FindItem(ItemID)
      if ThisScheduleItem:
         self.ScheduleItems.remove(ThisScheduleItem)
      self.SortSchedule()
      self.Save(True)


#/*********************************************/
#/* Sort the list of schedule items so the    */
#/* expired items are at the top of the list. */
#/*********************************************/
   def SortSchedule(self):
      self.ScheduleItems.sort(key=SortGetKey)


#/*************************************************************************/
#/* If the top schedule item is in the past return it's ID as being       */
#/* triggered. The schedule items are kept in date order, so the top item */
#/* is the one which will trigger first. The calling function is          */
#/* responsible for removing the triggered item from the scheduled items  */
#/* or updating the scheduled item if the item is to be  repeated once    */
#/* the calling function has processed it; by calling the function:       */
#/* SetNextScheduleDate().                                                */
#/*************************************************************************/
   def ScheduleTrigger(self):
      ThisItemID = False
      Now = datetime.datetime.now()
      ThisItem = self.GetItem(0)
      if ThisItem and ThisItem.GetScheduleDate() <= Now:
         ThisItemID = ThisItem.GetItemID()
      return ThisItemID


#/*********************************************************************/
#/* Set the date and time of the specified schedule item to it's next */
#/* trigger date/time. If the item does not have a repeat period,     */
#/* remove the schedule item.                                         */
#/*********************************************************************/
   def SetNextScheduleDate(self, ThisItemID):
      ThisItem = self.FindItem(ThisItemID)
      if ThisItem and ThisItem.SetNextScheduleDate() == False:
         self.DelSchedule(ThisItemID)
      self.SortSchedule()
      self.Save(False)


#/************************************************************************/
#/* Save all schedule items to a file, so they can be reloaded when the  */
#/* application next starts and continue where the application left off. */
#/************************************************************************/
   def Save(self, Force):
      Now = datetime.datetime.now()
      if Force or Now > self.SaveDateTime + self.SavePeriod:
         File = open("Data/Schedule.txt", 'w', 0)
         for ThisScheduleItem in self.ScheduleItems:
            ThisScheduleItem.Save(File)
         File.close()
         self.SaveDateTime = Now


#/******************************************************/
#/* Load all of the schedule items from a file, so the */
#/* application can resume where it last left off.     */
#/******************************************************/
   def Load(self):
      try:
         File = open("Data/Schedule.txt", 'r', 0)
         Result = True
         while Result:
            NewSchedule = ScheduleItem.ScheduleItem(0, 0, 0, 0)
            Result = NewSchedule.Load(File)
            if Result:
               self.ScheduleItems.append(NewSchedule)
         File.close()
         self.SortSchedule()
      except:
         print("")

The Python print statements have been changed to calls to the UserInterface class PrintLine member function, so displayed data is sent to the LCD and console window.

ScheduleItem.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to store a single schedule event in.                               */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime


# Constants to define relay state.
RELAY_TOGGLE = -1
RELAY_OFF = 0
RELAY_ON = 1


class ScheduleItem:

   def __init__(self, NewRelayNumber, NewScheduleDate, NewRelayState, NewRepeat):
# Unique ID to refer specicially to this specific instance of this class.
      self.ItemID = id(self)
# The ID of the relay this instance referrs to.
      self.RelayNumber = NewRelayNumber
# The time and date this schedule is to activate at.
      self.ScheduleDate = NewScheduleDate
# The state the relay is to be set to.
      self.RelayState = NewRelayState
# The period after activation for the schedule to activate again.
      self.Repeat = NewRepeat


#/****************************************************************/
#/* Return the unique ID of this spacific instance of the class. */
#/****************************************************************/
   def GetItemID(self):
      return self.ItemID


#/*******************************************************************/
#/* Return the relay number of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayNumber(self):
      return self.RelayNumber


#/*******************************************************************/
#/* Return the relay action of this spacific instance of the class. */
#/*******************************************************************/
   def GetRelayState(self):
      return self.RelayState


#/********************************************************************/
#/* Return the schedule date of this spacific instance of the class. */
#/********************************************************************/
   def GetScheduleDate(self):
      return self.ScheduleDate


#/*******************************************************/
#/* Update the schedule date to the next schedule date. */
#/*******************************************************/
   def SetNextScheduleDate(self):
      Now = datetime.datetime.now()
      if self.Repeat:
         while self.ScheduleDate < Now:
            self.ScheduleDate += self.Repeat
         return True
      else:
         return False


#/**********************************************************************/
#/* When tabulating the results, display a specific row for the table. */
#/**********************************************************************/
   def DisplayItem(self, UserInterface, LineNumber, SelectLeftChar):
      Period = int(self.Repeat.total_seconds())
      Seconds = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Minutes = operator.mod(Period, 60)
      Period = operator.div(Period, 60)
      Hours = operator.mod(Period, 24)
      Period = operator.div(Period, 24)
      Days = Period
      UserInterface.PrintLine(LineNumber,
      "{}{:^19}".format(SelectLeftChar, self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S")))
      UserInterface.PrintLine(LineNumber + 1,
                              "{}{:>2}={:<2}  {:>3} {:0>2}:{:0>2}:{:0>2}".format(SelectLeftChar,
                              self.RelayNumber, self.RelayState, str(Days), str(Hours),
                              str(Minutes), str(Seconds)))


#/********************************************************/
#/* Save this schedule item to the provided file handle. */
#/********************************************************/
   def Save(self, File):
      File.write(str(self.ItemID) + "," + str(self.RelayNumber) + ","
                 + self.ScheduleDate.strftime("%Y-%m-%d %H:%M:%S") + "," + str(self.RelayState)
                 + "," + str(int(self.Repeat.total_seconds())) + "\n")


#/**********************************************************************/
#/* Load the next schedule item details from the provided file handle. */
#/**********************************************************************/
   def Load(self, File):
      ThisLine = File.readline()
      if ThisLine:
         Fields = ThisLine.split(",")
         self.ItemID = string.atoi(Fields[0])
         self.RelayNumber = string.atoi(Fields[1])
         self.RelayState =  string.atoi(Fields[3])

         Period = string.atoi(Fields[4])
         Seconds = operator.mod(Period, 24 * 60 * 60)
         Days = operator.div(Period, 24 * 60 * 60)
         self.Repeat = datetime.timedelta(Days, Seconds)

         DateTime = Fields[2].split(" ")
         ThisDate = DateTime[0].split("-")
         ThisTime = DateTime[1].split(":")
         self.ScheduleDate = datetime.datetime(string.atoi(ThisDate[0]), string.atoi(ThisDate[1]),
                                               string.atoi(ThisDate[2]), string.atoi(ThisTime[0]),
                                               string.atoi(ThisTime[1]), string.atoi(ThisTime[2]))
      return ThisLine != ""

The Python print statements have been changed to calls to the UserInterface class PrintLine member function, so displayed data is sent to the LCD and console window.

SystemTime.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle system time procedures such as setting and reading the   */
#/* system time and setting and reading the clock module time.               */
#/****************************************************************************/


import os
import datetime


class SystemTime:

#/**************************************************************/
#/* Function to return the system time in a consistant format. */
#/**************************************************************/
   def SystemTimeString(self):
      Now = datetime.datetime.now()
      return Now.strftime("%Y-%m-%d  %H:%M:%S")


#/*******************************************************************/
#/* Function to set the system time to the specified date and time. */
#/*******************************************************************/
   def SetSystemTime(self, NewTime):
	   os.system("date -s '" + NewTime + "' > /dev/null")


#/*****************************************************************/
#/* Initialize the RTC module date and time from the system time. */
#/*****************************************************************/
   def InitModuleTime(self):
	   os.system("cd RPiRTCDriver; sudo ./RPiRTC /I > /dev/null")


#/*************************************************************/
#/* Read the date and time from the RTC module and return it. */
#/*************************************************************/
   def GetModuleTime(self):
      Result = ""
      os.system("cd RPiRTCDriver; sudo ./RPiRTC /G > RESULT.TXT")
      try:
         File = open("RPiRTCDriver/RESULT.TXT", 'r', 0)
         ThisLine = "X"
         while ThisLine != "":
            ThisLine = File.readline()
            if ThisLine[0:4] == "RTC:":
               Result = ThisLine[-20:-1]
         File.close()
      except:
         Result = ""
      return Result

The SystemTime class in this lesson is unchanged from the previous lesson. See the previous lesson for details.

UserInterface.py

Click to expand...

# PiTimer - Python Hardware Programming Education Project For Raspberry Pi
# Copyright (C) 2015 Jason Birch
#
# This program 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.
#
# This program 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 General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see .

#/****************************************************************************/
#/* PiTimer - Step 11 - 20 x 4 LCD display.                                  */
#/* ------------------------------------------------------------------------ */
#/* V1.00 - 2015-07-04 - Jason Birch                                         */
#/* ------------------------------------------------------------------------ */
#/* Class to handle user input, output display and interface state machine.  */
#/****************************************************************************/


import string
import operator
import datetime
import SystemTime
import Schedule
import ScheduleItem


# Constants to define current user interface display.
STATE_SPLASH = 0
STATE_MAIN_MENU = 1
STATE_ADD_SCHEDULE = 2
STATE_DEL_SCHEDULE = 3
STATE_RELAY_STATES = 4
STATE_SCHEDULE = 5
STATE_SET_SYSTEM_TIME = 6
STATE_SHUTDOWN = 7

# Constants to define display modes.
MODE_STANDARD = 0
MODE_CONFIRM = 1


class UserInterface:

   def __init__(self, NewWIndow, NewLCD, NewThisSchedule, NewThisRelays):
# Store a reference to the system window class to display onto.
      self.ThisWindow = NewWIndow
# Store a reference to the LCD module class.
      self.ThisLCD = NewLCD
# Store a reference to the schedule class to display schedule inforamtion.
      self.ThisSchedule = NewThisSchedule
# Store a reference to the relays class to display relay inforamtion.
      self.ThisRelays = NewThisRelays
# Create an instance of the system time class, to display the system time.
      self.ThisSystemTime = SystemTime.SystemTime()

# Buffer for input strings.
      self.InputBuffer = ""
# List position, moved by user.
      self.SelectPos = 0
      self.SelectID = 0
# Display application splash screen on initialisation.
      self.SetInterfaceState(STATE_SPLASH)


   def Clear(self):
      self.ThisLCD.Home()
      if self.ThisWindow:
         self.ThisWindow.clear()
         self.ThisWindow.refresh()


   def PrintLine(self, LineNumber, TextLine):
      self.ThisLCD.CacheLine(LineNumber, TextLine)
      if self.ThisWindow:
         print(TextLine + "\r")


#/***********************************************************************/
#/* Distribute key press events to the current user interface function. */
#/***********************************************************************/
   def KeyPress(self, KeyCode):
      Result = KeyCode
      if self.InterfaceState == STATE_SPLASH:
         Result = self.KeysSplash(KeyCode)
      elif self.InterfaceState == STATE_MAIN_MENU:
         Result = self.KeysMainMenu(KeyCode)
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         Result = self.KeysAddSchedule(KeyCode)
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         Result = self.KeysDelSchedule(KeyCode)
      elif self.InterfaceState == STATE_SCHEDULE:
         Result = self.KeysSchedule(KeyCode)
      elif self.InterfaceState == STATE_RELAY_STATES:
         Result = self.KeysRelayStates(KeyCode)
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         Result = self.KeysSetSystemTime(KeyCode)
      return Result


#/****************************************************************/
#/* Certain user interface displays need to update every second. */
#/****************************************************************/
   def DisplayRefresh(self):
      if self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*******************************************************/
#/* Change the current user interface to a new display. */
#/*******************************************************/
   def SetInterfaceState(self, NewInterfaceState):
# Start on standard display mode.
      self.Mode = MODE_STANDARD
# Clear the input buffer.
      self.InputBuffer = ""
# Reset list selection position.
      self.SelectPos =0
      self.SelectID = 0

      self.InterfaceState = NewInterfaceState

      if self.InterfaceState == STATE_SPLASH:
         self.DisplaySplash()
      elif self.InterfaceState == STATE_MAIN_MENU:
         self.DisplayMainMenu()
      elif self.InterfaceState == STATE_ADD_SCHEDULE:
         self.DisplayAddSchedule()
      elif self.InterfaceState == STATE_DEL_SCHEDULE:
         self.DisplayDelSchedule()
      elif self.InterfaceState == STATE_SCHEDULE:
         self.DisplaySchedule()
      elif self.InterfaceState == STATE_RELAY_STATES:
         self.DisplayRelayStates()
      elif self.InterfaceState == STATE_SET_SYSTEM_TIME:
         self.DisplaySetSystemTime()


#/*********************************************************/
#/* Provided the input from the user and a mask to define */
#/* how to display the input, format a string to display. */
#/*********************************************************/
   def GetMaskedInput(self, Mask, Input):
      InputCount = 0
      Result = ""
      for Char in Mask:
         if Char == "#" and len(Input) > InputCount:
            Result += Input[InputCount:InputCount + 1]
            InputCount += 1
         else:
            Result += Char
      return Result


#/************************************************/
#/* Gather the input required for an input mask. */
#/************************************************/
   def KeyMaskedInput(self, Mask, Input, KeyCode):
# If a valid key is pressed, add to the input buffer.
      if len(Input) < Mask.count("#") and KeyCode >= ord("0") and KeyCode <= ord("9"):
         Input += chr(KeyCode)
# If delete key is pressed, delete the last entered key.
      elif (KeyCode == 127 or KeyCode == ord("*")) and len(Input) > 0:
         Input = Input[:-1]
      return Input


#/***************************************************/
#/* Display a splash screen for application startup */
#/* to show information about this application.     */
#/***************************************************/
   def DisplaySplash(self):
      self.Clear()
      self.PrintLine(1, "{:^20}".format("PiTimer"))
      self.PrintLine(2, "{:^20}".format("2015-06-23"))
      self.PrintLine(3, "{:^20}".format("Version 1.00"))
      self.PrintLine(4, "{:^20}".format("(C) Jason Birch"))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysSplash(self, KeyCode):
      Result = KeyCode
# Display the initial user interface, the main menu.
      self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/*****************************/
#/* MAIN MENU user interface. */
#/*****************************/
   def DisplayMainMenu(self):
      self.Clear()
      self.PrintLine(1, "{:>20}".format(self.ThisSystemTime.SystemTimeString()))
      self.PrintLine(2, "{:^20}".format("1>Add     4>Schedule"))
      self.PrintLine(3, "{:^20}".format("2>Delete  5>Set Time"))
      self.PrintLine(4, "{:^20}".format("3>Relays  6>Shutdown"))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysMainMenu(self, KeyCode):
      Result = KeyCode
# If menu item 1 is selected, change to display add schedule.
      if KeyCode == ord("1"):
         self.SetInterfaceState(STATE_ADD_SCHEDULE)
# If menu item 2 is selected, change to display del schedule.
      if KeyCode == ord("2"):
         self.SetInterfaceState(STATE_DEL_SCHEDULE)
# If menu item 3 is selected, change to display relay states.
      if KeyCode == ord("3"):
         self.SetInterfaceState(STATE_RELAY_STATES)
# If menu item 4 is selected, change to display schedule.
      if KeyCode == ord("4"):
         self.SetInterfaceState(STATE_SCHEDULE)
# If menu item 5 is selected, change to display set system time.
      if KeyCode == ord("5"):
         self.SetInterfaceState(STATE_SET_SYSTEM_TIME)
# If menu item 6 is selected, return ESC key to the application main loop.
      if KeyCode == ord("6"):
         Result = 27
      return Result


#/********************************/
#/* RELAY STATES user interface. */
#/********************************/
   def DisplayRelayStates(self):
      self.Clear()
      self.ThisRelays.DisplayRelayStates(self)
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysRelayStates(self, KeyCode):
      Result = KeyCode
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* ADD SCHEDULE user interface. */
#/********************************/
   def DisplayAddSchedule(self):
      self.Clear()
      self.PrintLine(1, "{:^20}".format("ADD SCHEDULE"))
      self.PrintLine(2, self.GetMaskedInput("####-##-##  ##:##:##", self.InputBuffer[0:14]))
      self.PrintLine(3, self.GetMaskedInput("Period ###  ##:##:##", self.InputBuffer[14:23]))
      self.PrintLine(4, self.GetMaskedInput("Relay  ##    State #", self.InputBuffer[23:26]))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysAddSchedule(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:## ### ##:##:## ## #",
                                             self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
# If full user input has been gathered, add a schedule item.
         if len(self.InputBuffer) == 26:
# Parse user input.
            UserInput = self.GetMaskedInput("####-##-## ##:##:## ### ##:##:## ## #", self.InputBuffer)
            RelayState = {
               "0":ScheduleItem.RELAY_OFF,
               "1":ScheduleItem.RELAY_ON,
               "2":ScheduleItem.RELAY_TOGGLE,
            }.get(UserInput[36:37], ScheduleItem.RELAY_TOGGLE)

            PeriodSeconds = string.atoi(UserInput[30:32])
            + 60 * string.atoi(UserInput[27:29])
            + 60 * 60 * string.atoi(UserInput[24:26])
            + 24 * 60 * 60 * string.atoi(UserInput[20:23])
            PeriodDays = operator.div(PeriodSeconds, 24 * 60 * 60)
            PeriodSeconds = operator.mod(PeriodSeconds, 24 * 60 * 60)
# Add schedule item, ignore errors from invalid data entered.
            try:
               self.ThisSchedule.AddSchedule(string.atoi(UserInput[33:35]),
                                             datetime.datetime(string.atoi(UserInput[0:4]),
                                             string.atoi(UserInput[5:7]),
                                             string.atoi(UserInput[8:10]),
                                             string.atoi(UserInput[11:13]),
                                             string.atoi(UserInput[14:16]),
                                             string.atoi(UserInput[17:19])), RelayState,
                                             datetime.timedelta(PeriodDays, PeriodSeconds))
            except:
               if self.ThisWindow:
                  print("")
            if self.ThisWindow:
               self.ThisWindow.refresh()

         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/********************************/
#/* DEL SCHEDULE user interface. */
#/********************************/
   def DisplayDelSchedule(self):
      self.Clear()
      if self.Mode == MODE_STANDARD:
         self.PrintLine(1, "{:^20}".format("DELETE SCHEDULE"))
         self.PrintLine(2, "{: ^20}".format(""))
         if self.ThisSchedule.GetItemCount():
            self.SelectID = self.ThisSchedule.DisplaySchedule(self, 3, self.SelectPos, 1)
         else:
            self.PrintLine(3, "{:^20}".format("Empty"))
      elif self.Mode == MODE_CONFIRM:
         self.PrintLine(1, "{:^20}".format("DELETE SCHEDULE"))
         self.PrintLine(2, "{: ^20}".format(""))
         self.PrintLine(3, "{:^20}".format("ARE YOU SURE?"))
         self.PrintLine(4, "{:^20}".format("(4=N, 6=Y)"))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysDelSchedule(self, KeyCode):
      Result = KeyCode
      if self.Mode == MODE_STANDARD:
# If a key at the top of the keypad is pressed, move up the list.
         if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
            self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
         elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
               or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
            self.SelectPos += 1
# If enter key is pressed, enter confirm mode.
         if KeyCode == 10 or KeyCode == ord("#"):
            if self.ThisSchedule.GetItemCount():
               self.Mode = MODE_CONFIRM
            else:
               self.SetInterfaceState(STATE_MAIN_MENU)
# If delete key is pressed, change to display main menu.
         if KeyCode == 127 or KeyCode == ord("*"):
            self.SetInterfaceState(STATE_MAIN_MENU)
      elif self.Mode == MODE_CONFIRM:
         if KeyCode == ord("4"):
            self.SetInterfaceState(STATE_MAIN_MENU)
         elif KeyCode == ord("6"):
            self.ThisSchedule.DelSchedule(self.SelectID)
            self.SetInterfaceState(STATE_MAIN_MENU)

      return Result


#/************************************/
#/* CURRENT SCHEDULE user interface. */
#/************************************/
   def DisplaySchedule(self):
      self.Clear()
      if self.ThisSchedule.GetItemCount():
         self.ThisSchedule.DisplaySchedule(self, 1, self.SelectPos, 2)
      else:
         self.PrintLine(1, "{: ^20}".format(""))
         self.PrintLine(2, "{:^20}".format("Empty"))
         self.PrintLine(3, "{: ^20}".format(""))
         self.PrintLine(4, "{: ^20}".format(""))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysSchedule(self, KeyCode):
      Result = KeyCode
# If a key at the top of the keypad is pressed, move up the list.
      if (KeyCode == ord("1") or KeyCode == ord("2") or KeyCode == ord("3")) and self.SelectPos > 0:
         self.SelectPos -= 1
# If a key at the bottom of the keypad is pressed, move down the list.
      elif (KeyCode == ord("0") or KeyCode == ord("7") or KeyCode == ord("8")
            or KeyCode == ord("9")) and self.SelectPos < self.ThisSchedule.GetItemCount() - 1:
         self.SelectPos += 1
# If enter key is pressed, change to display main menu.
      elif KeyCode == 10 or KeyCode == ord("#"):
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result


#/***********************************/
#/* SET SYSTEM TIME user interface. */
#/***********************************/
   def DisplaySetSystemTime(self):
      self.Clear()
      self.PrintLine(1, "{:^20}".format("SET SYSTEM TIME"))
      self.PrintLine(2, self.GetMaskedInput("####-##-## ##:##:## ", self.InputBuffer))
      self.PrintLine(3, "{: ^20}".format(""))
      self.PrintLine(4, "{: ^20}".format(""))
      if self.ThisWindow:
         self.ThisWindow.refresh()


   def KeysSetSystemTime(self, KeyCode):
      Result = KeyCode
      self.InputBuffer = self.KeyMaskedInput("####-##-## ##:##:##", self.InputBuffer, KeyCode)
# If enter key is pressed, change to display main menu.
      if KeyCode == 10 or KeyCode == ord("#"):
# If full user input has been gathered, set the system time.
         if len(self.InputBuffer) == 14:
# Update the system time and the RTC module time to the date and time provided.
            self.ThisSystemTime.SetSystemTime(self.GetMaskedInput("####-##-## ##:##:##",
                                                                  self.InputBuffer))
            self.ThisSystemTime.InitModuleTime()
         self.SetInterfaceState(STATE_MAIN_MENU)
      return Result

A new interface state STATE_SPLASH and member functions DisplaySplash and KeysSplash have been added, to display a splash screen of the application version on application start.

Two other member functions have been added Clear and PrintLine. These perform the dual functions of updating the console display and LCD display at the same time. Then in the other member functions of the UserInterface class, where the display was cleared or a line of text was displayed, the code has been replaced with calls to these member functions.

PiTimer.sh

Click to expand...

#!/bin/bash

# sudo crontab -e
# @boot /home/pi/Desktop/PiTimer/PiTimer.sh

cd /home/pi/Desktop/PiTimer/
sudo python PiTimer.py 

# sudo shutdown -h now

Starting The Application Automatically
Now that the application can be run independently of a keyboard and monitor. It can be set to start automatically on boot by adding it to the bottom of the crontab file, with the following command. Ensure the path of the source code is updated to the location you have placed the source code. When it is tested and working you can uncomment the shutdown command so that the application automatically shutdown the system on exit.

sudo crontab -e
@reboot /home/pi/Desktop/PiTimer/PiTimer.sh

Running The Code
The driver module for the RTC module is required.
In a Terminal window, type the following to make it available to this application:
wget http://www.newsdownload.co.uk/downloads/RPiRTCDriver.tar.gz
tar -xf RPiRTCDriver.tar.gz

A directory called Data is required to save files into.
In a Terminal window, type the following:
mkdir Data
sudo python PiTimer.py

sudo is required to run the code as super user. This is so the application can set the system time and control the Raspberry Pi GPIO pins.

The project can now be used stand alone. On powering on, after booting the LCD display will display the application splash screen. Press a key on the keypad and the application main menu will be displayed. The keypad and LCD display can now be used to perform all functions of the application.

Driving Switching Devices
A transistor is required to drive switching devices. On my test LED board the transistors are just driving LEDs. Some transistors are capable of driving high voltages and/or high currents. However care must be taken when selecting a transistor, as some will require more power to switch than the Raspberry Pi is capable of supplying. Darlington drivers are a good choice to use, as they can drive large currents and have very high gain, which means they require a small amount of current to switch a large amount of current.

Designing a driver circuit here is beyond the scope of this article, it is a large topic and will depend entirely on the type of device you are trying to power.

NOTE: When driving a relay at least a transistor must be used and care taken when selecting the transistor. A reverse bias diode is also required, to prevent back EMF from the inductance of the relay coils.

Tasks To Try
The object of this article is to assist someone who wan't to program in Python. Allowing them to jump in at a very basic level, or skip some of the earlier stages if a basic understanding has already been achieved. It introduces concepts of design and reasoning behind taking decisions along the application design process.

At this stage you should have the full application running. As a challenge, here are some ideas to try, if you would like to attempt to modify the code. This would be a good idea to do, as I learned to program by typing in programs from magazines, such as Sinclair Programs and Sinclair User. Then understanding how they work by modifying them. Eventually writing my own programs. The great thing about learning to program is, if the program stops running, try and understand what went wrong or reload the original version and try again. Remember when writing code keep regular backups, they will come in handy from time to time, ideally use a version control system such as GIT, which will allow you to go to a point in time of your development process.

When the application starts, after the previous schedule items have been loaded. The schedule items will be loaded at the point they where saved, this could by many days ago. They will be repeatedly triggered until they get to what their current state should be. This is fine for schedules which trigger once an hour and doesn't take very long. But if you have a schedule which triggers every second and the application was last used a week ago, it can take a very long time to catch up. Devise a way which will run forward though the missed triggers quickly, so if a long period has passed since the application was shut down, the application starts swiftly.
Modify the application to provide a web interface, which can be used over WiFi.

If you modify the application and redistribute it, under the terms of the GNU Public License, you must keep all license details in place and a credit to myself as the original author of the software in place.

Raspberry Pi Multi Channel Timer

2015-07-05 21:05 By Jason Birch

A multi channel timer module which could be used for central heating, lighting, appliance, ... timing. Running independently with numeric keypad and LCD display.