WebSVN - Projects - Path Comparison - / Rev 729 and / Rev 730

Ignore whitespace Rev 729 → Rev 730

 /Transportables_Koptertool/trunk/CHANGE.LOG
 ,0 → 1,194
+/****************************************************************************
+ *   Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje                    *
+ *   admiralcascade@gmail.com                                               *
+ *   Project-URL: http://www.mylifesucks.de/oss/c-osd/                      *
+ *                                                                          *
+ *   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 2 of the License.         *
+ *                                                                          *
+ *   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, write to the                          *
+ *   Free Software Foundation, Inc.,                                        *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.              *
+ ****************************************************************************/
+20090612-2100
+    *spi transfer now struct driven (needs C-Strom 20090612-2100 now!!!)
+    *lesser spi update rate (caused problems on some strom-slaves)
+    *voltage gets transfered via spi as well
+    *menu to switch display of 2nd voltage measured by C-Strom on and off
+20090604-1350
+        *bugfix for stats
+20090604-1330
+        *possible to choose between different osd-layouts (via menu)
+20090604-0700
+        +(shaddi)osd_ncmode_minimal for less symbols during FPV
+20090601-2233
+        *(woggle) changed timer init an interupt to be more precise
+        *(woggle) remove all warning during compile
+        *(woggle) simplify draw_big_variometer
+        *(woggle) put compass rose to PROGMEM
+        *(woggle) put directions array to PROGMEM
+20090525-2305
+        +HUD on/off via RC (connect to PPM, according to manual) testing stuff
+20090523-1150
+        +pal/ntsc changable in menu (applied immedeately!)
+20090519-2245
+    *mah corrected
+    +config gets saved now (menu item!)
+    *source moved a bit
+20090519-0115
+    +mah currently wasted
+    *some small changes
+20090517-2345
+        *modded the real alpha stuff i have been talking about below
+20090516-2345
+        +some really testing stuff 'bout current measurement, more to come
+20090513-2350
+        *cellnumber autoconfig modified, offset set to 1,5V
+        *copy paste nick/roll error fixed
+        *clean after build in dist.sh
+        +a little shellscript to auto-build the files (testing)
+        *osd-layouts in seperate files so including own layouts should get easier
+        +build date is displayed during init to know which version you are runing
+20090513-1040
+    *some code movement
+    +artificial horizon for FC-ONLY mode
+20090512-2100
+    +some FCONLY basics (set FCONLY to 1 in main.h to use it)
+20090511-2345
+    *battery voltages now calculated according to CELL_VOLT_MIN CELL_VOLT_MAX and CELL_NUM
+    *CELL_NUM -1 causes a rough auto detection of cell number
+    -UBAT_WRN and UBAT_MAX are now deprecated
+20090427-2315
+    +write_gps_pos(...) (needs to be tested)
+    +gps position is shown in stats screen for testing purpose
+20090427-2131
+    *stats are only collected while engines running (shaddi)
+20090427-2102
+    *fixed maximum distance in stats (shaddi)
+20090427-2050
+    *clear() now faster
+    *fixed calculation of max speed in stats (shaddi)
+    *littel typo in artificial horizon (thx joko)
+    *stats are only shown AFTER flight (more specific, after motors had been on at least once)
+    +indication icon for serial link (requires new character 198)
+    +indication icon for manual controll (stick > stick threshold)
+    (Character set 192 needs to be reflashed since new icon is in it)
+20090420-0205
+    *reset-bug fixed
+    *moved code a bit
+20090419-2145
+        *reset-bug workaround in usart1.c: usart1_DisableTXD and usart1_EnableTXD
+20090419-1900
+        *fixed bug in heading-fine conv for bearing to home
+20090419-1245
+        *compass characters bigger
+        *battery position
+        +voltage-symbol to battery-voltage
+        (Character Set 208 needs to be reflashed since compass chars are in it)
+20090418-2015
+        *fixed bug in Character Set 128 (reflash it if you already flashed it!)
+        +another set of vario chars
+        *changed vario to use new characters
+        *moved vario/home-bearing positions
+        *big vario now enabled via menu or BIGVARIO
+        (Character Set 112 needs to be flashed)
+20090418-1235
+        +big vario for testing purpose
+        (Character Set 192 needs to be flashed)
+20090418-0100
+        *variometer uses more steps (9 instead of 5)
+        *home-arrow is now home-clock using more steps (22,5° resolution)
+        +visual battery-gauge according to difference between UBAT_WRN and UBAT_MAX
+20090417-1115
+        *changed calculation of km/h (thx wowie)
+        *added JochenK_(joko)'s characters
+        (Character-Sets 128, 136, 144, 152, 160, 168, 176 and 184 need to be flashed!)
+20090408-1245 (shaddi)
+        *fixed distance towards home
+20090408-0035
+        *rewrote number->display functions
+        *fixed height bug (uint vs int)
+20090407-2100
+    +added request of OSD data, disrequest of debug data and uptime reset to menu
+    -removed the uptime-reset binding from S2
+    +pgm space for some strings to save _normal_ data space
+    *some code movement
+20090406-0130
+        *MK-Datastruct updated to work with NaviCtrl 0.15c firmware
+        *changed flags from NO* to invers versions
+        *enhanced the menu a bit
+        -artificial horizon at bootup, the menu is cooler imho
+20090405-0207
+        +NOOSD as requested
+        *height now corrected (thx lephisto) and displayed as .x up to 10m
+20090402-0106
+        + disabling the txd pin while not using it so it won't interfere with KopterTool usage (thx joko)
+        + if no data has been received for over 2sec we re-request it
+        * tried source organisation a bit
+20090401-1741 (shaddi)
+        + More precise Veriometer. Uses more more characters to show the speed of the movement
+          (Character-Set 232 needs to be flashed!)
+20090331-1549
+        + simple config menu during runtime, press S1 to jump in, S2 to cyle and S1 to accept choice
+        - S1 no longer requests the NC data
+20090331-1305
+        + added more statistics
+        * corrected S1/S2 mapping (d'oh)
+        + started simple mode controll, press S2 during bootup toggles artificial horizon
+20090329-1452
+        * fixed bearing to home
+        + added flight stats (shown while engines off)
+        + sat icon should indicate PH/CH/Free now
+        + you need to flash characters 224-231 if you were using previous versions
+20090327-2140
+        * fixed km/h (was cm/s)
+        * fixed height m (was dm)
+        * modified incoming data speed to 100ms (was 200ms)
+20090326-2031
+        + first binary release

 /Transportables_Koptertool/trunk/LICENSE.TXT
 ,0 → 1,340
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.
+Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+                            Preamble
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Library General Public License instead.)  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
+this service 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 make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  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.
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+  The precise terms and conditions for copying, distribution and
+modification follow.
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+and 2 above on a medium customarily used for software interchange; or,
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+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
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+. The Free Software Foundation may publish revised and/or new versions
+of the 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 a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+                            NO WARRANTY
+. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
+. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE 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.
+                     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
+convey 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 2 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, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+Also add information on how to contact you by electronic and paper mail.
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision 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, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+This 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 Library General
+Public License instead of this License.

/Transportables_Koptertool/trunk/MMB 1.pdf
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

/Transportables_Koptertool/trunk/MMB 1.sch
Cannot display: file marked as a binary type.
svn:mime-type = application/octet-stream
Property changes:
Added: svn:mime-type
+application/octet-stream
\ No newline at end of property

 /Transportables_Koptertool/trunk/Makefile
 ,0 → 1,505
+#-------------------------------------------------------------------
+# Use only one!
+# _M_obiles _M_ikrokopter _T_ool http://forum.mikrokopter.de/topic-4061-1.html
+# MK Multi Box
+BOARD = MMT
+#
+#BOARD = xxx
+#-------------------------------------------------------------------
+VERSION_MAJOR =  0
+VERSION_MINOR =  2
+VERSION_PATCH =  1
+VERSION_SERIAL_MAJOR = 10 # Serial Protocol Major Version
+VERSION_SERIAL_MINOR = 0  # Serial Protocol Minor Version
+#-------------------------------------------------------------------
+# get SVN revision
+REV := $(shell sh -c "cat .svn/entries | sed -n '4p'")
+ifeq ($(BOARD), MMT)
+ # The original with ATmega32 and 7.3 MHz
+ MCU = atmega32
+ F_CPU = 7372800
+ QUARZ = 7MHZ
+ FUSE_SETTINGS = -u -U lfuse:w:0x3f:m -U hfuse:w:0xcf:m
+ HEX_NAME = $(BOARD)_MEGA32
+endif
+ifeq ($(BOARD), MMB)
+ # MK Multi Box with ATmega644p and 20 MHz
+ MCU = atmega644p
+ F_CPU = 20000000
+ QUARZ = 20MHZ
+ FUSE_SETTINGS = -u -U lfuse:w:0xd7:m -U hfuse:w:0xdf:m -U efuse:w:0xfc:m
+ HEX_NAME = $(BOARD)_MEGA644p
+endif
+ifeq ($(BOARD), MMB1)
+ # original board. ATmega32 replaced with ATmega644p
+ MCU = atmega644p
+ F_CPU = 7372800
+ QUARZ = 7MHZ
+ FUSE_SETTINGS = -u -U lfuse:w:0xd7:m -U hfuse:w:0xdf:m -U efuse:w:0xfc:m
+ HEX_NAME = $(BOARD)_MEGA644p
+endif
+# Output format. (can be srec, ihex, binary)
+FORMAT = ihex
+# Target file name (without extension).
+ifeq ($(VERSION_PATCH), 0)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)a_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 1)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)b_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 2)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)c_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 3)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)d_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 4)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)e_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 5)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)f_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 6)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)g_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 7)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)h_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 8)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)i_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 9)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)j_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 10)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)k_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 11)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)l_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 12)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)m_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 13)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)n_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 14)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)o_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 15)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)p_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 16)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)q_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 17)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)r_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 18)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)s_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 19)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)t_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 20)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)u_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 21)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)v_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 22)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)w_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 23)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)x_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 24)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)y_SVN$(REV)
+endif
+ifeq ($(VERSION_PATCH), 25)
+TARGET = $(HEX_NAME)_V$(VERSION_MAJOR)_$(VERSION_MINOR)z_SVN$(REV)
+endif
+# Optimization level, can be [0, 1, 2, 3, s]. 0 turns off optimization.
+# (Note: 3 is not always the best optimization level. See avr-libc FAQ.)
+OPT = s
+##########################################################################################################
+# List C source files here. (C dependencies are automatically generated.)
+ifeq ($(BOARD), MMT)
+SRC     = main.c menu.c timer.c lcd.c font8X6.c usart.c settings.c motortest.c display.c osd.c debug.c parameter.c status.c eeprom.c
+else
+SRC     = main.c menu.c timer.c lcd.c font8X6.c font8x8.c usart.c settings.c motortest.c display.c osd.c debug.c jeti.c servo.c lipo.c parameter.c status.c eeprom.c
+endif
+##########################################################################################################
+# List Assembler source files here.
+# Make them always end in a capital .S.  Files ending in a lowercase .s
+# will not be considered source files but generated files (assembler
+# output from the compiler), and will be deleted upon "make clean"!
+# Even though the DOS/Win* filesystem matches both .s and .S the same,
+# it will preserve the spelling of the filenames, and gcc itself does
+# care about how the name is spelled on its command-line.
+ASRC =
+# List any extra directories to look for include files here.
+#     Each directory must be seperated by a space.
+EXTRAINCDIRS =
+# Optional compiler flags.
+#  -g:        generate debugging information (for GDB, or for COFF conversion)
+#  -O*:       optimization level
+#  -f...:     tuning, see gcc manual and avr-libc documentation
+#  -Wall...:  warning level
+#  -Wa,...:   tell GCC to pass this to the assembler.
+#    -ahlms:  create assembler listing
+CFLAGS  = -O$(OPT)
+CFLAGS += -funsigned-char
+CFLAGS += -funsigned-bitfields
+CFLAGS += -fpack-struct
+CFLAGS += -fshort-enums
+CFLAGS += -Wall
+CFLAGS += -Wstrict-prototypes
+CFLAGS += -Wa,-adhlns=$(<:.c=.lst)
+CFLAGS += $(patsubst %,-I%,$(EXTRAINCDIRS))
+# Compiler flag to set the C Standard level.
+#   Unremark just one line below to set the language standard to use.
+#     c89   = "ANSI" C
+#     gnu89 = c89 plus GCC extensions
+#     c99   = ISO C99 standard (not yet fully implemented)
+#     gnu99 = c99 plus GCC extensions
+#CFLAGS += -std=c89
+#CFLAGS += -std=gnu89
+#CFLAGS += -std=c99
+CFLAGS += -std=gnu99
+CFLAGS += -DF_CPU=$(F_CPU)
+CFLAGS += -DQUARZ=$(QUARZ)
+CFLAGS += -DVERSION_MAJOR=$(VERSION_MAJOR)
+CFLAGS += -DVERSION_MINOR=$(VERSION_MINOR)
+CFLAGS += -DVERSION_PATCH=$(VERSION_PATCH)
+CFLAGS += -DVERSION_SERIAL_MAJOR=$(VERSION_SERIAL_MAJOR)
+CFLAGS += -DVERSION_SERIAL_MINOR=$(VERSION_SERIAL_MINOR)
+ifeq ($(BOARD), MMT)
+ CFLAGS += -DUSE_MMT
+endif
+ifeq ($(BOARD), MMB)
+ CFLAGS += -DUSE_MMB
+endif
+ifeq ($(BOARD), MMB1)
+ CFLAGS += -DUSE_MMB1
+endif
+# Optional assembler flags.
+#  -Wa,...:   tell GCC to pass this to the assembler.
+#  -ahlms:    create listing
+#  -gstabs:   have the assembler create line number information; note that
+#             for use in COFF files, additional information about filenames
+#             and function names needs to be present in the assembler source
+#             files -- see avr-libc docs [FIXME: not yet described there]
+ASFLAGS = -Wa,-adhlns=$(<:.S=.lst),-gstabs
+# Optional linker flags.
+#  -Wl,...:   tell GCC to pass this to linker.
+#  -Map:      create map file
+#  --cref:    add cross reference to  map file
+LDFLAGS = -Wl,-Map=$(TARGET).map,--cref
+# Additional libraries
+# Minimalistic printf version
+#LDFLAGS += -Wl,-u,vfprintf -lprintf_min
+# Floating point printf version (requires -lm below)
+#LDFLAGS += -Wl,-u,vfprintf -lprintf_flt
+# -lm = math library
+LDFLAGS += -lm
+##LDFLAGS += -T./linkerfile/avr5.x
+# Programming support using avrdude. Settings and variables.
+# Programming hardware:
+#
+# Type: avrdude -c ?
+# to get a full listing.
+#
+AVRDUDE_PROGRAMMER = usbasp
+#falls Ponyser ausgewählt wird, muss sich unsere avrdude-Configdatei im Bin-Verzeichnis des Compilers befinden
+#AVRDUDE_PORT = com1    # programmer connected to serial device
+#AVRDUDE_PORT = lpt1    # programmer connected to parallel port
+#AVRDUDE_PORT = usb     # programmer connected to USB
+AVRDUDE_WRITE_FLASH = -U flash:w:$(TARGET).hex
+AVRDUDE_WRITE_FUSE = $(FUSE_SETTINGS)
+AVRDUDE_WRITE_EEPROM = -U eeprom:w:$(TARGET).eep
+#avrdude -c avrispv2 -P usb -p m32 -U flash:w:blink.hex
+#AVRDUDE_FLAGS = -p $(MCU) -P $(AVRDUDE_PORT) -c $(AVRDUDE_PROGRAMMER)
+AVRDUDE_FLAGS = -p $(MCU) -c $(AVRDUDE_PROGRAMMER)
+# Uncomment the following if you want avrdude's erase cycle counter.
+# Note that this counter needs to be initialized first using -Yn,
+# see avrdude manual.
+#AVRDUDE_ERASE += -y
+# Uncomment the following if you do /not/ wish a verification to be
+# performed after programming the device.
+AVRDUDE_FLAGS += -V
+# Increase verbosity level.  Please use this when submitting bug
+# reports about avrdude. See <http://savannah.nongnu.org/projects/avrdude>
+# to submit bug reports.
+#AVRDUDE_FLAGS += -v -v
+# ---------------------------------------------------------------------------
+# Define directories, if needed.
+#DIRAVR = c:/winavr
+#DIRAVRBIN = $(DIRAVR)/bin
+#DIRAVRUTILS = $(DIRAVR)/utils/bin
+#DIRINC = .
+#DIRLIB = $(DIRAVR)/avr/lib
+# Define programs and commands.
+SHELL = sh
+CC = avr-gcc
+OBJCOPY = avr-objcopy
+OBJDUMP = avr-objdump
+SIZE = avr-size
+# Programming support using avrdude.
+AVRDUDE = avrdude
+REMOVE = rm -f
+COPY = cp
+HEXSIZE = $(SIZE) --target=$(FORMAT) $(TARGET).hex
+##ELFSIZE = $(SIZE) -A $(TARGET).elf
+ELFSIZE = $(SIZE) --mcu=$(MCU) --format=avr $(TARGET).elf
+# Define Messages
+# English
+MSG_ERRORS_NONE = Errors: none
+MSG_BEGIN = -------- begin --------
+MSG_END = --------  end  --------
+MSG_SIZE_BEFORE = Size before:
+MSG_SIZE_AFTER = Size after:
+MSG_COFF = Converting to AVR COFF:
+MSG_EXTENDED_COFF = Converting to AVR Extended COFF:
+MSG_FLASH = Creating load file for Flash:
+MSG_EEPROM = Creating load file for EEPROM:
+MSG_EXTENDED_LISTING = Creating Extended Listing:
+MSG_SYMBOL_TABLE = Creating Symbol Table:
+MSG_LINKING = Linking:
+MSG_COMPILING = Compiling:
+MSG_ASSEMBLING = Assembling:
+MSG_CLEANING = Cleaning project:
+# Define all object files.
+OBJ = $(SRC:.c=.o) $(ASRC:.S=.o)
+# Define all listing files.
+LST = $(SRC:.c=.lst) $(ASRC:.S=.lst)
+# Combine all necessary flags and optional flags.
+# Add target processor to flags.
+#ALL_CFLAGS = -mmcu=$(MCU) -DF_CPU=$(F_CPU) -I. $(CFLAGS)
+ALL_CFLAGS = -mmcu=$(MCU) -I. $(CFLAGS)
+ALL_ASFLAGS = -mmcu=$(MCU) -I. -x assembler-with-cpp $(ASFLAGS)
+# Default target.
+all: begin gccversion sizebefore $(TARGET).elf $(TARGET).hex $(TARGET).eep \
+        $(TARGET).lss $(TARGET).sym sizeafter finished end
+# Eye candy.
+# AVR Studio 3.x does not check make's exit code but relies on
+# the following magic strings to be generated by the compile job.
+begin:
+        @echo
+        @echo $(MSG_BEGIN)
+finished:
+        @echo $(MSG_ERRORS_NONE)
+end:
+        @echo $(MSG_END)
+        @echo
+# Display size of file.
+sizebefore:
+        @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_BEFORE); $(ELFSIZE); echo; fi
+sizeafter:
+        @if [ -f $(TARGET).elf ]; then echo; echo $(MSG_SIZE_AFTER); $(ELFSIZE); echo; fi
+# Display compiler version information.
+gccversion :
+        @$(CC) --version
+# Convert ELF to COFF for use in debugging / simulating in
+# AVR Studio or VMLAB.
+COFFCONVERT=$(OBJCOPY) --debugging \
+        --change-section-address .data-0x800000 \
+        --change-section-address .bss-0x800000 \
+        --change-section-address .noinit-0x800000 \
+        --change-section-address .eeprom-0x810000
+coff: $(TARGET).elf
+        @echo
+        @echo $(MSG_COFF) $(TARGET).cof
+        $(COFFCONVERT) -O coff-avr $< $(TARGET).cof
+extcoff: $(TARGET).elf
+        @echo
+        @echo $(MSG_EXTENDED_COFF) $(TARGET).cof
+        $(COFFCONVERT) -O coff-ext-avr $< $(TARGET).cof
+# Program the device.
+flash: $(TARGET).hex
+        $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FLASH)
+eeprom: $(TARGET).eep
+        $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_EEPROM)
+fuse:
+        $(AVRDUDE) $(AVRDUDE_FLAGS) $(AVRDUDE_WRITE_FUSE)
+reset:
+        $(AVRDUDE) $(AVRDUDE_FLAGS)
+# Create final output files (.hex, .eep) from ELF output file.
+%.hex: %.elf
+        @echo
+        @echo $(MSG_FLASH) $@
+        $(OBJCOPY) -O $(FORMAT) -R .eeprom $< $@
+%.eep: %.elf
+        @echo
+        @echo $(MSG_EEPROM) $@
+        -$(OBJCOPY) -j .eeprom --set-section-flags=.eeprom="alloc,load" \
+        --change-section-lma .eeprom=0 -O $(FORMAT) $< $@
+# Create extended listing file from ELF output file.
+%.lss: %.elf
+        @echo
+        @echo $(MSG_EXTENDED_LISTING) $@
+        $(OBJDUMP) -h -S $< > $@
+# Create a symbol table from ELF output file.
+%.sym: %.elf
+        @echo
+        @echo $(MSG_SYMBOL_TABLE) $@
+        avr-nm -n $< > $@
+# Link: create ELF output file from object files.
+.SECONDARY : $(TARGET).elf
+.PRECIOUS : $(OBJ)
+%.elf: $(OBJ)
+        @echo
+        @echo $(MSG_LINKING) $@
+        $(CC) $(ALL_CFLAGS) $(OBJ) --output $@ $(LDFLAGS)
+# Compile: create object files from C source files.
+%.o : %.c
+        @echo
+        @echo $(MSG_COMPILING) $<
+        $(CC) -c $(ALL_CFLAGS) $< -o $@
+# Compile: create assembler files from C source files.
+%.s : %.c
+        $(CC) -S $(ALL_CFLAGS) $< -o $@
+# Assemble: create object files from assembler source files.
+%.o : %.S
+        @echo
+        @echo $(MSG_ASSEMBLING) $<
+        $(CC) -c $(ALL_ASFLAGS) $< -o $@
+# Target: clean project.
+clean: begin clean_list finished end
+clean_list :
+        @echo
+        @echo $(MSG_CLEANING)
+#       $(REMOVE) $(TARGET).hex
+        $(REMOVE) $(TARGET).eep
+        $(REMOVE) $(TARGET).obj
+        $(REMOVE) $(TARGET).cof
+        $(REMOVE) $(TARGET).elf
+        $(REMOVE) $(TARGET).map
+        $(REMOVE) $(TARGET).obj
+        $(REMOVE) $(TARGET).a90
+        $(REMOVE) $(TARGET).sym
+        $(REMOVE) $(TARGET).lnk
+        $(REMOVE) $(TARGET).lss
+        $(REMOVE) $(OBJ)
+        $(REMOVE) $(LST)
+        $(REMOVE) $(SRC:.c=.s)
+        $(REMOVE) $(SRC:.c=.d)
+        @echo
+# Automatically generate C source code dependencies.
+# (Code originally taken from the GNU make user manual and modified
+# (See README.txt Credits).)
+#
+# Note that this will work with sh (bash) and sed that is shipped with WinAVR
+# (see the SHELL variable defined above).
+# This may not work with other shells or other seds.
+#
+%.d: %.c
+        @set -e; $(CC) -MM $(ALL_CFLAGS) $< \
+        | sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > $@; \
+        [ -s $@ ] || rm -f $@
+# Remove the '-' if you want to see the dependency files generated.
+-include $(SRC:.c=.d)
+# Listing of phony targets.
+.PHONY : all begin finish end sizebefore sizeafter gccversion coff extcoff clean clean_list flash eeprom fuse reset

 /Transportables_Koptertool/trunk/README.txt
 ,0 → 1,189
+MK Multi Box:
+=============
+Stand: 12.02.2010
+Was kann die MMB:
+- Anzeige der OSD-Daten
+- MK Display
+- MK Motor Test
+- MK Debug-Daten
+- Jeti Box
+- Servo Tester
+Das muß noch geschrieben/überarbeitet/getestet werde:
+- MK Parameter
+- LiPo Überwachung
+- I2C-Tester für BL-Ctrl
+Die MMB entstand aus dem Projekt "Transportables Kopter Tool" von thkais:
+http://www.ft-fanpage.de/mikrokopter/
+und
+http://forum.mikrokopter.de/topic-4061-1.html
+Das Projekt hatte ich mal auf Lochraster nachgebaut.
+Leider war es kurz nach dem Bau ziemlich nutzlos.
+Die FC bekam ein Firmware-Update und niemand hat sich um die Software-Anpassung des Tools gekümmert. :-(
+So lag es denn einige Monate und staubte vor sich hin...
+Mitte 2009 wollte ich mich mit den AVRs beschäftigen und
+mir etwas basteln um die OSD-Daten vom MK zu visualisieren.
+Und zufällig schweift mein Blick über die verstaubte Kopter-Tool Hardware. ;-)
+Herausgekommen ist die MMB.
+Die Hardware basiert weitestgehend auf dem Entwurf von thkais.
+Ich habe nur etwas "modernisiert", d.h. den ATmega32 durch einen ATmega644p mit 20 MHz ersetzt.
+Die genauen Hardware-Details finden sich im Schaltplan, der auch im Eagle-Format vorliegt.
+Die "tausend" LEDs habe ich mir nur als "Debug-Hilfe" dazugebastelt
+und können auch weggelassen werden.
+Entwickelt habe ich auf dem Mac (Mac OS X 10.6) mit Crosspack. Als Editor mußte XCode herhalten.
+Der Source sollte sich aber auch unter Linux oder (zur Not) auch Windows mit den entsprechenden AVR-Tools compilieren lassen.
+Die Tasten
+^  v  ⎋  ⏎
+^ - Up
+v - Down
+⎋ - Escape/Back/Top
+⏎ - Enter
+Wenn genug Platz im Display vorhanden ist, wird in der untersten Zeile die aktuelle
+Tastenbelegung eingeblendet. Das ist aber leider nicht immer möglich.
+Hauptmenü:
+==========
+- Navi Data
+- Display
+- Parameters
+- Debug Data
+- Jeti
+- Utilities...
+) Navi Data
+Anzeige des OSD Datensatzes der NC.
+Tasten:
+---- ---- Exit Status
+Beim Stoppen der Motoren wird einen Statusseite angezeigt.
+Die Statusseite kann auch gezielt mit der Status-taste ausgerufen werden.
+Tasten (Statusseite):
+---- ---- Exit ----
+) Display
+Anzeigen des MK-Displays.
+Tasten:
+page- page+ Exit NC/FC
+) Parameters
+-- noch nicht funktionsfähig ---
+Auslesen und Ändern der FC Parameter.
+) Debug Data
+Anzeige der MK Debug Daten.
+Tasten:
+page- page+ Exit NC/FC
+) Jeti
+Die MK Multi Box arbeitet als "Jeti Box".
+Die Belegung der Tasten hat sich wie folgt geändert:
+^  v  <  >
+^ - Up
+v - Down
+< - Left
+> - Right
+Die "Jeti Box"-Funktion wird über längeres Drückern der <-Taste (Left) verlassen.
+) Utilities...
+Weiter zum Sub-Menü "Utilities".
+Utilities:
+==========
+- Motor Test
+- Servo Tester
+- LiPo Status
+- Status
+- Settings...
+) Motor Test
+MK Motortest
+) Servo Tester
+Generiert einen Servo Puls mit variabler Länge von 1.0 ms bis 2.0 ms
+mit einer Wiederholrate vom 20 ms.
+Tasten:
+-10 +10 Exit >|<
+-10 - -10 Steps
++10 - +10 Steps
+Exit - Servo-Test verlassen
+>|< - Servo in Mittenposition (1,5 ms)
+Langes Drücken auf >|< schaltet die Schrittweite auf +1/-1 um.
+Schrittweite ist 0,32 µs.
+) LiPo Status
+Anzeige der Zellenspannungen eines LiPos bis max 4S.
+) Status
+Einige Statusinformationen...
+) Settings...
+Weiter zum Sub-Menü "Settings".
+Settings:
+=========
+- Orientation
+- LiPo Warn
+- View Font
+- Line
+- Rectangle
+) Orientation
+Anzeige um 128 Grad drehen.
+Einstellung wird im EEPROM gespeichert.
+) LiPo Warn
+Einstellen der Warnschwelle
+) View Font
+Anzeige des 6x8 Fonts.
+) Line
+***TEST
+) Rectangle
+***TEST
+Source:
+=======
+Das Makefile unterstützt im Moment drei Hardware-Typen:
+- das originale "Transportable Kopter Tool": ATmega32 mit 7 MHz
+- originale Hardware aber mit ATmega644P (7 MHz)
+- MK Multi Box (siehe Eagle Schaltbild): ATmega644P mit 20 MHz
+Der Hardware-Typ wird im Makefile eingestellt.
+Ziele fürs make:
+- make clean
+  ordentlich aufräumen ;-)
+- make
+  HEX-File erzeugen
+- make flash
+  Zielsystem flashen
+- make fuse
+  FUSE-Bits programmieren
+- make reset
+  Zielsystem via Programmer resetten

 /Transportables_Koptertool/trunk/TODO.txt
 ,0 → 1,8
+- MK Parameter
+- LiPo Überwachung
+  Warnung ausgeben!
+- I2C BL-Ctrl Tester
+  entweder zusammen mit dem Motor-Test (einfach alle Motoren bzw. alle I2C BL-Ctrl Adressen) oder
+        als extra Menü und Reglernummer wählbar

 /Transportables_Koptertool/trunk/VERSION.txt
 ,0 → 1,13
+20100208:
+- erste offizielle Version
+- für Firmware FC 0.76 / NC 0.
+20100213:
+- Anpassung an die neue Firmware FC 0.78 / NC 0.18
+  abo_timeout: bei Funktionen mit Abonnement muß das Abonnement regelmäßig erneuert werden! Es läuft sonst nach 4 s aus.
+        OSD: Flugzeit und RC-Quality um eine Zeile nach oben verschoben.
+                         In die unterste Zeile stehen nun aktuelle Spannung, aktueller Strom und verbrauchte Kapazität direkt nebeneinander.
+                         In der Statusseite des OSD mußten die kryptischen Lat./Long.-Angaben dem max. Strom und der verbrauchten Kapazität weichen.
+  Display: Umbau auf die neue Konvention
+- Kompatibilität zur Original-Hardware (hoffentlich) wieder hergestellt

 /Transportables_Koptertool/trunk/debug.c
 ,0 → 1,332
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+// @TODO: maybe choose a smaler font for the debug data. 6x6 or 6x7 would be nice and gives some additional space for status lines
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include <string.h>
+#include "main.h"
+#include "menu.h"
+#include "lcd.h"
+#include "usart.h"
+#include "debug.h"
+#include "timer.h"
+#include "mk-data-structs.h"
+#define TIMEOUT 200             // 2 sec
+#define ANALOGTIME 20   // 200 ms
+// WARNING: this work for NC & FC only
+//          if current_hardware == MK3MAG or MKGPS the access is outside of the array...
+#if defined (__AVR_ATmega32__)
+uint8_t AnalogNames[32][16 + 1];        // 32 names, 16 characters + 1 0x00
+uint8_t AnalogNamesRead = 0;
+// um noch mehr Speicherplatz zu sparen, könnte man auch nur die jeweils benötigten Labels anfordern...
+#else
+uint8_t AnalogNames[2][32][16 + 1];     // 32 names, 16 characters + 1 0x00
+uint8_t AnalogNamesRead[2] = {0,0};
+#endif
+//*****************************************************************************
+//
+void GetAnalogNames (void)
+{
+#if defined (__AVR_ATmega32__)
+        uint8_t i = AnalogNamesRead;
+#else
+        uint8_t i = AnalogNamesRead[current_hardware - 1];
+#endif
+        uint8_t t = 0;
+        lcd_cls ();
+        lcd_printp_at (0, 3, PSTR("Reading"), 0);
+        lcd_printp_at (0, 4, PSTR("Analog Names: "), 0);
+        mode = 'A';     // read Names
+        _delay_ms(200);
+        rxd_buffer_locked = FALSE;
+        timer = ANALOGTIME;
+        while (i < 32)
+        {
+                SendOutData ('a', ADDRESS_ANY, 1, &i, 1);
+                while (!rxd_buffer_locked && timer);
+                if (timer)
+                {
+                        Decode64 ();
+                        if (i == *pRxData)
+                        {
+                                write_ndigit_number_u(14, 4, i, 2, 0);
+#if defined (__AVR_ATmega32__)
+                                memcpy (AnalogNames[*pRxData], (uint8_t *) pRxData + 1, 16);
+                                AnalogNames[*pRxData][16] = 0;
+#else
+                                memcpy (AnalogNames[current_hardware - 1][*pRxData], (uint8_t *) pRxData + 1, 16);
+                                AnalogNames[current_hardware - 1][*pRxData][16] = 0;
+#endif
+                                i++;
+                                t = 0;
+                        }
+                        else
+                        {
+                                _delay_ms (100);
+                        }
+                        timer = ANALOGTIME;
+                        rxd_buffer_locked = FALSE;
+                }
+                else
+                {       // timeout occured
+                        t++;
+                        timer = ANALOGTIME;
+                        if (t >= 50)
+                        {
+                                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                                timer = 100;
+                                while (timer > 0);
+                                break;
+                        }
+                }
+        }
+#if defined (__AVR_ATmega32__)
+        AnalogNamesRead = i;
+#else
+        AnalogNamesRead[current_hardware - 1] = i;
+#endif
+#if 0
+        if (timer)
+        {
+                for (page = 0; page < 4; page++)
+                {
+                        for (i = 0; i < 7; i++)
+                        {
+                                lcd_print_at (0, i, AnalogNames[current_hardware - 1][i + page * 8], 0);
+                        }
+                        while (!get_key_press (1 << KEY_ESC));  // ESC
+                }
+        }
+        //return;
+#endif
+}
+//*****************************************************************************
+//
+void display_debug (void)
+{
+        uint8_t i = 0;
+        uint8_t tmp_dat;
+        uint8_t page = 0;
+        DebugData_t *DebugData;
+        lcd_cls ();
+        timer = TIMEOUT;
+#if defined (__AVR_ATmega32__)
+        if (AnalogNamesRead < 32) {
+#else
+        if (AnalogNamesRead[current_hardware - 1] < 32) {
+#endif
+                GetAnalogNames ();
+        }
+        if (!timer)
+        {
+                return;
+        }
+        mode = 'D';     // Debug Data
+        rxd_buffer_locked = FALSE;
+        timer = TIMEOUT;
+        tmp_dat = 10;
+        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+        abo_timer = ABO_TIMEOUT;
+        for (i = 0; i < 8; i++)
+        {
+#if defined (__AVR_ATmega32__)
+                lcd_print_at (0, i, AnalogNames[i + page * 8], 0);
+#else
+                lcd_print_at (0, i, AnalogNames[current_hardware - 1][i + page * 8], 0);
+#endif
+        }
+        do
+        {
+                if (rxd_buffer_locked)
+                {
+                        Decode64 ();
+                        DebugData = (DebugData_t *) pRxData;
+                        //lcd_printp_at (0,6,PSTR("Page"),0);
+                        lcd_write_number_u_at (20, 0, page);
+                        switch (current_hardware)
+                        {
+                                case FC:
+                                        lcd_printp_at (20, 1, PSTR("F"), 0);
+                                        break;
+                                case NC:
+                                        lcd_printp_at (20, 1, PSTR("N"), 0);
+                                        break;
+                                default:
+                                        lcd_printp_at (20, 1, PSTR("?"), 0);
+                                        break;
+                        }
+                        for (i = 0; i < 8; i++)
+                        {
+                                //lcd_print_at (0, i, AnalogNames[i + page * 8], 0);
+                                if (current_hardware == NC)
+                                {
+                                        write_ndigit_number_u (14, i, DebugData->Analog[i + page * 8], 5, 0);
+                                }
+                                else
+                                {
+                                        write_ndigit_number_s (14, i, DebugData->Analog[i + page * 8], 5, 0);
+                                }
+                        }
+                        timer = TIMEOUT;
+                        rxd_buffer_locked = FALSE;
+                }
+                if (!abo_timer)
+                {       // renew abo every 3 sec
+                        // request OSD Data from NC every 100ms
+                        //      RS232_request_mk_data (1, 'o', 100);
+                        tmp_dat = 10;
+                        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+                        abo_timer = ABO_TIMEOUT;
+                }
+                if (get_key_press (1 << KEY_MINUS))
+                {
+                        page--;
+                        page &= 0x03;
+                        lcd_cls ();
+                        for (i = 0; i < 8; i++)
+                        {
+#if defined (__AVR_ATmega32__)
+                                lcd_print_at (0, i, AnalogNames[i + page * 8], 0);
+#else
+                                lcd_print_at (0, i, AnalogNames[current_hardware - 1][i + page * 8], 0);
+#endif
+                        }
+                }
+                else if (get_key_press (1 << KEY_PLUS))
+                {
+                        page++;
+                        page &= 0x03;
+                        lcd_cls ();
+                        for (i = 0; i < 8; i++)
+                        {
+#if defined (__AVR_ATmega32__)
+                                lcd_print_at (0, i, AnalogNames[i + page * 8], 0);
+#else
+                                lcd_print_at (0, i, AnalogNames[current_hardware - 1][i + page * 8], 0);
+#endif
+                        }
+                }
+                if ((hardware == NC) && get_key_press (1 << KEY_ENTER))
+                {
+                        tmp_dat = 0;
+                        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+                        _delay_ms (200);
+                        if (current_hardware == NC)
+                        {
+                                SwitchToFC();
+                                timer = TIMEOUT;
+                                //lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  NC"), 0);
+                        }
+                        else
+                        {
+                                SwitchToNC();
+                                timer = TIMEOUT;
+                                //lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  FC"), 0);
+                        }
+                        _delay_ms (200);
+#if defined (__AVR_ATmega32__)
+                        AnalogNamesRead = 0;
+                        GetAnalogNames ();
+#else
+                        if (AnalogNamesRead[current_hardware - 1] < 32) {
+                                GetAnalogNames ();
+                        }
+#endif
+                        mode = 'D';     // Debug Data
+                        rxd_buffer_locked = FALSE;
+                        timer = TIMEOUT;
+                        tmp_dat = 10;
+                        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+                        lcd_cls ();
+                        page = 0;
+                        for (i = 0; i < 8; i++)
+                        {
+#if defined (__AVR_ATmega32__)
+                                lcd_print_at (0, i, AnalogNames[i + page * 8], 0);
+#else
+                                lcd_print_at (0, i, AnalogNames[current_hardware - 1][i + page * 8], 0);
+#endif
+                        }
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC) && timer); // ESC
+        tmp_dat = 0;
+        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+        mode = 0;
+        rxd_buffer_locked = FALSE;
+        if (!timer)
+        {       // timeout occured
+                lcd_cls ();
+                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                timer = 100;
+                while (timer > 0);
+        }
+}

 /Transportables_Koptertool/trunk/debug.h
 ,0 → 1,36
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _DEBUG_H
+#define _DEBUG_H
+//*****************************************************************************
+//
+#if defined (__AVR_ATmega32__)
+extern uint8_t AnalogNamesRead;
+#else
+extern uint8_t AnalogNamesRead[2];
+#endif
+//*****************************************************************************
+//
+void display_debug(void);
+#endif

 /Transportables_Koptertool/trunk/displ_val.c
 ,0 → 1,88
+#include <avr/io.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <avr/pgmspace.h>
+#include "main.h"
+#include "lcd.h"
+#include "usart.h"
+// Insgesamt 32 Werte können angezeigt werden
+// jeweils 8 Stück werden gleichzeitg angezeigt
+// Auswahl über Tasten
+uint8_t displ_page;
+void displ_get_text (uint8_t number)
+{
+#if 0
+        uint8_t text[17];
+        uint8_t i;
+        buffer[0] = '#';
+        buffer[1] = 'a';
+        buffer[2] = 'a';
+        buffer[3] = number;
+        buffer[4] = 0;
+        buffer[5] = 0;
+//      base64_send(6);
+        do
+        {
+//              get_message ();
+        }
+        while (buffer[1] != 'A');
+        for (i = 0; i < 16; i++)
+                text[i] = buffer[i];
+        text[16] = 0x00;
+        lcd_print_at (0, (number & 0x07), text, 0);
+#endif
+}
+void displ_values (void)
+{
+#if 0
+        uint8_t displ_page, i;
+        int16_t value;
+        uint8_t text[17];
+        displ_page = 0;         // Page 0..3 (4 Pages zu je 8 Werte)
+        lcd_cls ();                             // LCD löschen
+        do
+        {
+                for (i = 0; i < 8; i++) // Texte lesen und anzeigen
+                        displ_get_text (i + displ_page * 8);
+                do
+                {
+//                      get_message ();
+                        if (buffer[1] == 'D')
+                        {
+                                for (i = 0; i < 8; i++)
+                                {
+                                        value = buffer[i * 2 + displ_page * 16 + 2] + 256 * buffer[i * 2 + displ_page * 16 + 3];
+                                        itoa (value, text, 10);
+                                        lcd_printp_at (14, i, PSTR("      "), 0);
+                                        lcd_print_at (14, i, text, 0);
+                                }
+                        }
+                }
+                while (key == key_nokey);
+                if (key == key_minus)
+                        displ_page++;
+                if (key == key_plus)
+                        displ_page--;
+                displ_page &= 0x03;
+        }
+        while (key != key_enter);
+#endif
+}

 /Transportables_Koptertool/trunk/displ_val.h
 ,0 → 1,9
+#ifndef _DISPL_VAL_H
+#define _DISPL_VAL_H
+//*****************************************************************************
+//
+void displ_values(void);
+#endif

 /Transportables_Koptertool/trunk/display.c
 ,0 → 1,159
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include "main.h"
+#include "lcd.h"
+#include "usart.h"
+#include "timer.h"
+#include "mk-data-structs.h"
+#define TIMEOUT 500     // 5 sec
+void display_data (void)
+{
+        uint8_t cmd;
+        uint8_t flag = 0;;
+        mode = 'H';
+        lcd_cls ();
+        if (current_hardware == NC)
+        {
+                lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  FC"), 0);
+        }
+        else
+        {
+                if (hardware == FC)
+                {
+                        lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit"), 0);
+                }
+                else
+                {
+                        lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  NC"), 0);
+                }
+        }
+        lcd_printp_at (0, 0, PSTR("Display"), 0);
+        rxd_buffer_locked = FALSE;
+        timer = TIMEOUT;
+        cmd = 0xfc;     // Home = first page
+        do
+        {
+                SendOutData('h', ADDRESS_ANY, 1, &cmd, 1);
+                cmd = 0xff;
+                //LED6_TOGGLE;
+                _delay_ms (250);
+                if (rxd_buffer_locked)
+                {
+                        Decode64 ();
+                        flag = 1;
+                        if (!hardware)
+                        {       // hardware was not detected at startup
+                                hardware = rxd_buffer[1] - 'a';
+                                if (hardware == NC)
+                                {
+                                        lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  FC"), 0);
+                                        current_hardware = NC;
+                                }
+                                else
+                                {
+                                        lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit"), 0);
+                                        current_hardware = FC;
+                                }
+                        }
+#if 0
+                        rxd_buffer[24] = 0;
+                        lcd_print_at (0, rxd_buffer[3] + 1, (uint8_t *) &rxd_buffer[4], 0);
+#else
+                        rxd_buffer[83] = 0;
+                        print_display_at (0, 2, (uint8_t *) &rxd_buffer[3]);
+#endif
+                        rxd_buffer_locked = FALSE;
+                        timer = TIMEOUT;
+                }
+                if (get_key_press (1 << KEY_MINUS))
+                {
+                        cmd = 0xfe;     // next page
+                        LED1_TOGGLE;
+                        //SendOutData('h', ADDRESS_ANY, 1, &cmd, 1);
+                        //cmd = 0;
+                }
+                else if (get_key_press (1 << KEY_PLUS))
+                {
+                        cmd = 0xfd;     // previous page
+                        LED2_TOGGLE;
+                        //SendOutData('h', ADDRESS_ANY, 1, &cmd, 1);
+                        //cmd = 0;
+                }
+                else if ((hardware == NC) && get_key_press (1 << KEY_ENTER))
+                {
+                        if (current_hardware == NC)
+                        {
+                                SwitchToFC();
+                                //timer = TIMEOUT;
+                                lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  NC"), 0);
+                                LED3_TOGGLE;
+                        }
+                        else
+                        {
+                                SwitchToNC();
+                                //timer = TIMEOUT;
+                                lcd_printpns_at (0, 7, PSTR(" \x1c    \x1d     Exit  FC"), 0);
+                                LED4_TOGGLE;
+                        }
+                        cmd = 0xfc;     // Home = first page
+                        //SendOutData('h', ADDRESS_ANY, 1, &cmd, 1);
+                        //cmd = 0;
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC) && timer);
+        get_key_press(KEY_ALL);
+        mode = 0;
+        rxd_buffer_locked = FALSE;
+        if (!timer)
+        {       // timeout occured
+                if (flag)
+                {
+                        lcd_cls ();
+                }
+                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                timer = 100;
+                while (timer > 0);
+        }
+        LED_ALL_OFF;
+}

 /Transportables_Koptertool/trunk/display.h
 ,0 → 1,27
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _DISPLAY_H
+#define _DISPLAY_H
+//*****************************************************************************
+//
+void display_data (void);
+#endif

 /Transportables_Koptertool/trunk/eeprom.c
 ,0 → 1,68
+/*****************************************************************************
+ *   Copyright (C) 2010 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/eeprom.h>
+#include <avr/pgmspace.h>
+#include "eeprom.h"
+#include "lcd.h"
+#ifndef USE_MMT
+#include "lipo.h"
+#endif
+#include "timer.h"
+//*****************************************************************************
+//
+unsigned char EEPromArray[E2END+1] EEMEM;
+//*****************************************************************************
+//
+void WriteParameterDefaults (void)
+{
+        eeprom_write_byte(&EEPromArray[EEPROM_ADDR_VALID], EEPROM_REV);
+        eeprom_write_byte(&EEPromArray[EEPROM_ADDR_ORIENTATION], 0);
+#ifndef USE_MMT
+        eeprom_write_byte(&EEPromArray[EEPROM_ADDR_LIPO], 33);
+#endif
+}
+//*****************************************************************************
+//
+void ReadParameter (void)
+{
+        if ((eeprom_read_byte(&EEPromArray[EEPROM_ADDR_VALID])) != EEPROM_REV)
+        {
+                WriteParameterDefaults();
+        }
+        LCD_ORIENTATION = eeprom_read_byte (&EEPromArray[EEPROM_ADDR_ORIENTATION]);
+#ifndef USE_MMT
+        AD_WarnLevel = eeprom_read_byte (&EEPromArray[EEPROM_ADDR_LIPO]);
+#endif
+}
+//*****************************************************************************
+//
+void WriteParameter (void)
+{
+        eeprom_write_byte(&EEPromArray[EEPROM_ADDR_ORIENTATION], LCD_ORIENTATION);
+#ifndef USE_MMT
+        eeprom_write_byte(&EEPromArray[EEPROM_ADDR_LIPO], AD_WarnLevel);
+#endif
+}

 /Transportables_Koptertool/trunk/eeprom.h
 ,0 → 1,34
+/*****************************************************************************
+ *   Copyright (C) 2010 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _EEPROM_H
+#define _EEPROM_H
+#define EEPROM_REV 1    // please increment when adding or changing parameters!
+#define EEPROM_ADDR_VALID                                       1
+#define EEPROM_ADDR_ORIENTATION         2
+#define EEPROM_ADDR_LIPO                                        3
+//*****************************************************************************
+//
+void ReadParameter (void);
+void WriteParameter (void);
+#endif

 /Transportables_Koptertool/trunk/font8X6.c
 ,0 → 1,158
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   - font provided by Claas Anders "CaScAdE" Rathje                        *
+ *   - umlauts and special characters by Peter "woggle" Mack                 *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/pgmspace.h>
+// one byte is a column
+// bit 7 is the bottom
+prog_uint8_t font8x6[128][6] =
+{
+        { 0x78,0x15,0x14,0x15,0x78,0x00 },      // ASCII -   0    'Ä'
+        { 0x20,0x55,0x54,0x55,0x78,0x00 },      // ASCII -   1    'ä'
+        { 0x38,0x45,0x44,0x45,0x38,0x00 },      // ASCII -   2    'Ö'
+        { 0x30,0x49,0x48,0x49,0x30,0x00 },      // ASCII -   3    'ö'
+        { 0x3c,0x41,0x40,0x41,0x3c,0x00 },      // ASCII -   4    'Ü'
+        { 0x38,0x41,0x40,0x21,0x78,0x00 },      // ASCII -   5    'ü'
+        { 0x7e,0x15,0x15,0x15,0x0a,0x00 },      // ASCII -   6    'ß'
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -   7
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -   8
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -   9
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  10  A (not useable)
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  11  B
+        { 0x10,0x38,0x54,0x10,0x10,0x1e },      // ASCII -  12  C Enter Symbol
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  13  D (not useable)
+        { 0x10,0x10,0x10,0x10,0x10,0x10 },      // ASCII -  14  E hor. line
+        { 0x10,0x10,0x10,0x7c,0x10,0x10 },      // ASCII -  15  F hor. line with tick mark
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  16 10
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  17 11
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  18 12
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  19 13
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  20 14
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  21 15
+        { 0x04,0x02,0x7f,0x02,0x04,0x00 },      // ASCII -  22 16 Arrow up
+        { 0x10,0x20,0x7f,0x20,0x10,0x00 },      // ASCII -  23 17 Arrow down
+        { 0x10,0x38,0x54,0x10,0x10,0x10 },      // ASCII -  24 18 <-
+        { 0x10,0x10,0x10,0x54,0x38,0x10 },      // ASCII -  25 19 ->
+        { 0x10,0x18,0x1c,0x1c,0x18,0x10 },      // ASCII -  26 1A ^
+        { 0x08,0x18,0x38,0x38,0x18,0x08 },      // ASCII -  27 1B v
+        { 0x00,0x08,0x1c,0x3e,0x7f,0x00 },      // ASCII -  28 1C <
+        { 0x00,0x7f,0x3e,0x1c,0x08,0x00 },      // ASCII -  29 1D >
+        { 0x06,0x09,0x09,0x09,0x06,0x00 },      // ASCII -  30 1E '°'
+        { 0x06,0x49,0x7d,0x49,0x06,0x00 },      // ASCII -  31 1F RC-Tx
+        { 0x00,0x00,0x00,0x00,0x00,0x00 },      // ASCII -  32 20 ' '
+        { 0x00,0x00,0x2f,0x00,0x00,0x00 },      // ASCII -  33 21 '!'
+        { 0x00,0x07,0x00,0x07,0x00,0x00 },      // ASCII -  34 22 '"'
+        { 0x14,0x7f,0x14,0x7f,0x14,0x00 },      // ASCII -  35 23 '#'
+        { 0x24,0x2a,0x6b,0x2a,0x12,0x00 },      // ASCII -  36 24 '$'
+        { 0x23,0x13,0x08,0x64,0x62,0x00 },      // ASCII -  37 25 '%'
+        { 0x36,0x49,0x55,0x22,0x50,0x00 },      // ASCII -  38 26 '&'
+        { 0x00,0x05,0x03,0x00,0x00,0x00 },      // ASCII -  39 27 '''
+        { 0x00,0x1c,0x22,0x41,0x00,0x00 },      // ASCII -  40 28 '('
+        { 0x00,0x41,0x22,0x1c,0x00,0x00 },      // ASCII -  41 29 ')'
+        { 0x14,0x08,0x3e,0x08,0x14,0x00 },      // ASCII -  42 2a '*'
+        { 0x08,0x08,0x3e,0x08,0x08,0x00 },      // ASCII -  43 2b '+'
+        { 0x00,0x50,0x30,0x00,0x00,0x00 },      // ASCII -  44 2c ','
+        { 0x08,0x08,0x08,0x08,0x08,0x00 },      // ASCII -  45 2d '-'
+        { 0x00,0x60,0x60,0x00,0x00,0x00 },      // ASCII -  46 2e '.'
+        { 0x20,0x10,0x08,0x04,0x02,0x00 },      // ASCII -  47 2f '/'
+        { 0x3e,0x51,0x49,0x45,0x3e,0x00 },      // ASCII -  48 30 '0'
+        { 0x00,0x42,0x7f,0x40,0x00,0x00 },      // ASCII -  49 31 '1'
+        { 0x42,0x61,0x51,0x49,0x46,0x00 },      // ASCII -  50 32 '2'
+        { 0x21,0x41,0x45,0x4b,0x31,0x00 },      // ASCII -  51 33 '3'
+        { 0x18,0x14,0x12,0x7f,0x10,0x00 },      // ASCII -  52 34 '4'
+        { 0x27,0x45,0x45,0x45,0x39,0x00 },      // ASCII -  53 35 '5'
+        { 0x3c,0x4a,0x49,0x49,0x30,0x00 },      // ASCII -  54 36 '6'
+        { 0x03,0x01,0x71,0x09,0x07,0x00 },      // ASCII -  55 37 '7'
+        { 0x36,0x49,0x49,0x49,0x36,0x00 },      // ASCII -  56 38 '8'
+        { 0x06,0x49,0x49,0x29,0x1e,0x00 },      // ASCII -  57 39 '9'
+        { 0x00,0x36,0x36,0x00,0x00,0x00 },      // ASCII -  58 3a ':'
+        { 0x00,0x56,0x36,0x00,0x00,0x00 },      // ASCII -  59 3b ';'
+        { 0x08,0x14,0x22,0x41,0x00,0x00 },      // ASCII -  60 3c '<'
+        { 0x14,0x14,0x14,0x14,0x14,0x00 },      // ASCII -  61 3d '='
+        { 0x00,0x41,0x22,0x14,0x08,0x00 },      // ASCII -  62 3e '>'
+        { 0x02,0x01,0x51,0x09,0x06,0x00 },      // ASCII -  63 3f '?'
+        { 0x32,0x49,0x79,0x41,0x3e,0x00 },      // ASCII -  64 40 '@'
+        { 0x7e,0x11,0x11,0x11,0x7e,0x00 },      // ASCII -  65 41 'A'
+        { 0x7f,0x49,0x49,0x49,0x36,0x00 },      // ASCII -  66 42 'B'
+        { 0x3e,0x41,0x41,0x41,0x22,0x00 },      // ASCII -  67 43 'C'
+        { 0x7f,0x41,0x41,0x22,0x1c,0x00 },      // ASCII -  68 44 'D'
+        { 0x7f,0x49,0x49,0x49,0x41,0x00 },      // ASCII -  69 45 'E'
+        { 0x7f,0x09,0x09,0x09,0x01,0x00 },      // ASCII -  70 46 'F'
+        { 0x3e,0x41,0x49,0x49,0x7a,0x00 },      // ASCII -  71 47 'G'
+        { 0x7f,0x08,0x08,0x08,0x7f,0x00 },      // ASCII -  72 48 'H'
+        { 0x00,0x41,0x7f,0x41,0x00,0x00 },      // ASCII -  73 49 'I'
+        { 0x20,0x40,0x41,0x3f,0x01,0x00 },      // ASCII -  74 4a 'J'
+        { 0x7f,0x08,0x14,0x22,0x41,0x00 },      // ASCII -  75 4b 'K'
+        { 0x7f,0x40,0x40,0x40,0x40,0x00 },      // ASCII -  76 4c 'L'
+        { 0x7f,0x02,0x0c,0x02,0x7f,0x00 },      // ASCII -  77 4d 'M'
+        { 0x7f,0x04,0x08,0x10,0x7f,0x00 },      // ASCII -  78 4e 'N'
+        { 0x3e,0x41,0x41,0x41,0x3e,0x00 },      // ASCII -  79 4f 'O'
+        { 0x7f,0x09,0x09,0x09,0x06,0x00 },      // ASCII -  80 50 'P'
+        { 0x3e,0x41,0x51,0x21,0x5e,0x00 },      // ASCII -  81 51 'Q'
+        { 0x7f,0x09,0x19,0x29,0x46,0x00 },      // ASCII -  82 52 'R'
+        { 0x46,0x49,0x49,0x49,0x31,0x00 },      // ASCII -  83 53 'S'
+        { 0x01,0x01,0x7f,0x01,0x01,0x00 },      // ASCII -  84 54 'T'
+        { 0x3f,0x40,0x40,0x40,0x3f,0x00 },      // ASCII -  85 55 'U'
+        { 0x1f,0x20,0x40,0x20,0x1f,0x00 },      // ASCII -  86 56 'V'
+        { 0x3f,0x40,0x38,0x40,0x3f,0x00 },      // ASCII -  87 57 'W'
+        { 0x63,0x14,0x08,0x14,0x63,0x00 },      // ASCII -  88 58 'X'
+        { 0x07,0x08,0x70,0x08,0x07,0x00 },      // ASCII -  89 59 'Y'
+        { 0x61,0x51,0x49,0x45,0x43,0x00 },      // ASCII -  90 5a 'Z'
+        { 0x7f,0x41,0x41,0x00,0x00,0x00 },      // ASCII -  91 5b '['
+        { 0x02,0x04,0x08,0x10,0x20,0x00 },      // ASCII -  92 5c '\'
+        { 0x00,0x41,0x41,0x7f,0x00,0x00 },      // ASCII -  93 5d ']'
+        { 0x04,0x02,0x01,0x02,0x04,0x00 },      // ASCII -  94 5e '^'
+        { 0x40,0x40,0x40,0x40,0x40,0x00 },      // ASCII -  95 5f '_'
+        { 0x00,0x01,0x02,0x04,0x00,0x00 },      // ASCII -  96 60 '`'
+        { 0x20,0x54,0x54,0x54,0x78,0x00 },      // ASCII -  97 61 'a'
+        { 0x7f,0x48,0x44,0x44,0x38,0x00 },      // ASCII -  98 62 'b'
+        { 0x38,0x44,0x44,0x44,0x20,0x00 },      // ASCII -  99 63 'c'
+        { 0x38,0x44,0x44,0x48,0x7f,0x00 },      // ASCII - 100 64 'd'
+        { 0x38,0x54,0x54,0x54,0x18,0x00 },      // ASCII - 101 65 'e'
+        { 0x08,0x7e,0x09,0x01,0x02,0x00 },      // ASCII - 102 66 'f'
+        { 0x0c,0x52,0x52,0x52,0x3e,0x00 },      // ASCII - 103 67 'g'
+        { 0x7f,0x08,0x04,0x04,0x78,0x00 },      // ASCII - 104 68 'h'
+        { 0x00,0x44,0x7d,0x40,0x00,0x00 },      // ASCII - 105 69 'i'
+        { 0x20,0x40,0x44,0x3d,0x00,0x00 },      // ASCII - 106 6a 'j'
+        { 0x7f,0x10,0x28,0x44,0x00,0x00 },      // ASCII - 107 6b 'k'
+        { 0x00,0x41,0x7f,0x40,0x00,0x00 },      // ASCII - 108 6c 'l'
+        { 0x7c,0x04,0x18,0x04,0x78,0x00 },      // ASCII - 109 6d 'm'
+        { 0x7c,0x08,0x04,0x04,0x78,0x00 },      // ASCII - 110 6e 'n'
+        { 0x38,0x44,0x44,0x44,0x38,0x00 },      // ASCII - 111 6f 'o'
+        { 0x7c,0x14,0x14,0x14,0x08,0x00 },      // ASCII - 112 70 'p'
+        { 0x08,0x14,0x14,0x18,0x7c,0x00 },      // ASCII - 113 71 'q'
+        { 0x7c,0x08,0x04,0x04,0x08,0x00 },      // ASCII - 114 72 'r'
+        { 0x48,0x54,0x54,0x54,0x20,0x00 },      // ASCII - 115 73 's'
+        { 0x04,0x3f,0x44,0x40,0x20,0x00 },      // ASCII - 116 74 't'
+        { 0x3c,0x40,0x40,0x20,0x7c,0x00 },      // ASCII - 117 75 'u'
+        { 0x1c,0x20,0x40,0x20,0x1c,0x00 },      // ASCII - 118 76 'v'
+        { 0x3c,0x40,0x38,0x40,0x3c,0x00 },      // ASCII - 119 77 'w'
+        { 0x44,0x28,0x10,0x28,0x44,0x00 },      // ASCII - 120 78 'x'
+        { 0x0c,0x50,0x50,0x50,0x3c,0x00 },      // ASCII - 121 79 'y'
+        { 0x44,0x64,0x54,0x4c,0x44,0x00 },      // ASCII - 122 7a 'z'
+        { 0x00,0x08,0x36,0x41,0x00,0x00 },      // ASCII - 123 7b '{'
+        { 0x00,0x00,0x7f,0x00,0x00,0x00 },      // ASCII - 124 7c '|'
+        { 0x00,0x41,0x36,0x08,0x00,0x00 },      // ASCII - 125 7d '}'
+        { 0x08,0x08,0x2a,0x1c,0x08,0x00 },      // ASCII - 126 7e ->
+        { 0x08,0x1c,0x2a,0x08,0x08,0x00 },      // ASCII - 127 7f <-
+};

 /Transportables_Koptertool/trunk/font8x6.h
 ,0 → 1,31
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   - font provided by Claas Anders "CaScAdE" Rathje                        *
+ *   - umlauts and special characters by Peter "woggle" Mack                 *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _FONT8X6_H
+#define _FONT8X6_H
+#include <avr/pgmspace.h>
+//*****************************************************************************
+//
+extern prog_uint8_t font8x6[128][6];
+#endif

 /Transportables_Koptertool/trunk/font8x8.c
 ,0 → 1,271
+/*
+ *  font8x8.c
+ *  LCD-OSD
+ *
+ *  Created by Peter Mack on 26.12.09.
+ *  Copyright 2009 SCS GmbH & Co. KG. All rights reserved.
+ *
+ */
+#include <avr/pgmspace.h>
+prog_uint8_t font8x8[256][8]={
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x00
+        {0x7E,0x81,0x95,0xB1,0xB1,0x95,0x81,0x7E},      // 0x01
+        {0x7E,0xFF,0xEB,0xCF,0xCF,0xEB,0xFF,0x7E},      // 0x02
+        {0x0E,0x1F,0x3F,0x7E,0x3F,0x1F,0x0E,0x00},      // 0x03
+        {0x08,0x1C,0x3E,0x7F,0x3E,0x1C,0x08,0x00},      // 0x04
+        {0x38,0x3A,0x9F,0xFF,0x9F,0x3A,0x38,0x00},      // 0x05
+        {0x10,0x38,0xBC,0xFF,0xBC,0x38,0x10,0x00},      // 0x06
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x07
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x08
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x09
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x0A
+        {0x70,0xF8,0x88,0x88,0xFD,0x7F,0x07,0x0F},      // 0x0B
+        {0x00,0x4E,0x5F,0xF1,0xF1,0x5F,0x4E,0x00},      // 0x0C
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x0D
+        {0xC0,0xFF,0x7F,0x05,0x05,0x65,0x7F,0x3F},      // 0x0E
+        {0x99,0x5A,0x3C,0xE7,0xE7,0x3C,0x5A,0x99},      // 0x0F
+        {0x7F,0x3E,0x3E,0x1C,0x1C,0x08,0x08,0x00},      // 0x10
+        {0x08,0x08,0x1C,0x1C,0x3E,0x3E,0x7F,0x00},      // 0x11
+        {0x00,0x24,0x66,0xFF,0xFF,0x66,0x24,0x00},      // 0x12
+        {0x00,0x5F,0x5F,0x00,0x00,0x5F,0x5F,0x00},      // 0x13
+        {0x06,0x0F,0x09,0x7F,0x7F,0x01,0x7F,0x7F},      // 0x14
+        {0xDA,0xBF,0xA5,0xA5,0xFD,0x59,0x03,0x02},      // 0x15
+        {0x00,0x70,0x70,0x70,0x70,0x70,0x70,0x00},      // 0x16
+        {0x80,0x94,0xB6,0xFF,0xFF,0xB6,0x94,0x80},      // 0x17
+        {0x00,0x04,0x06,0x7F,0x7F,0x06,0x04,0x00},      // 0x18
+        {0x00,0x10,0x30,0x7F,0x7F,0x30,0x10,0x00},      // 0x19
+        {0x08,0x08,0x08,0x2A,0x3E,0x1C,0x08,0x00},      // 0x1A
+        {0x08,0x1C,0x3E,0x2A,0x08,0x08,0x08,0x00},      // 0x1B
+        {0x3C,0x3C,0x20,0x20,0x20,0x20,0x20,0x00},      // 0x1C
+        {0x08,0x1C,0x3E,0x08,0x08,0x3E,0x1C,0x08},      // 0x1D
+        {0x30,0x38,0x3C,0x3E,0x3E,0x3C,0x38,0x30},      // 0x1E
+        {0x06,0x0E,0x1E,0x3E,0x3E,0x1E,0x0E,0x06},      // 0x1F
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},      // 0x20
+        {0x00,0x06,0x5F,0x5F,0x06,0x00,0x00,0x00},      // 0x21
+        {0x00,0x07,0x07,0x00,0x07,0x07,0x00,0x00},      // 0x22
+        {0x14,0x7F,0x7F,0x14,0x7F,0x7F,0x14,0x00},      // 0x23
+        {0x24,0x2E,0x6B,0x6B,0x3A,0x12,0x00,0x00},      // 0x24
+        {0x46,0x66,0x30,0x18,0x0C,0x66,0x62,0x00},      // 0x25
+        {0x30,0x7A,0x4F,0x5D,0x37,0x7A,0x48,0x00},      // 0x26
+        {0x04,0x07,0x03,0x00,0x00,0x00,0x00,0x00},      // 0x27
+        {0x00,0x1C,0x3E,0x63,0x41,0x00,0x00,0x00},      // 0x28
+        {0x00,0x41,0x63,0x3E,0x1C,0x00,0x00,0x00},      // 0x29
+        {0x08,0x2A,0x3E,0x1C,0x1C,0x3E,0x2A,0x08},      // 0x2A
+        {0x08,0x08,0x3E,0x3E,0x08,0x08,0x00,0x00},      // 0x2B
+        {0x00,0xA0,0xE0,0x60,0x00,0x00,0x00,0x00},      // 0x2C
+        {0x08,0x08,0x08,0x08,0x08,0x08,0x00,0x00},      // 0x2D
+        {0x00,0x00,0x60,0x60,0x00,0x00,0x00,0x00},      // 0x2E
+        {0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00},      // 0x2F
+        {0x3E,0x7F,0x59,0x4D,0x7F,0x3E,0x00,0x00},      // 0x30
+        {0x42,0x42,0x7F,0x7F,0x40,0x40,0x00,0x00},      // 0x31
+        {0x62,0x73,0x59,0x49,0x6F,0x66,0x00,0x00},      // 0x32
+        {0x22,0x63,0x49,0x49,0x7F,0x36,0x00,0x00},      // 0x33
+        {0x18,0x1C,0x16,0x13,0x7F,0x7F,0x10,0x00},      // 0x34
+        {0x27,0x67,0x45,0x45,0x7D,0x39,0x00,0x00},      // 0x35
+        {0x3C,0x7E,0x4B,0x49,0x79,0x30,0x00,0x00},      // 0x36
+        {0x03,0x63,0x71,0x19,0x0F,0x07,0x00,0x00},      // 0x37
+        {0x36,0x7F,0x49,0x49,0x7F,0x36,0x00,0x00},      // 0x38
+        {0x06,0x4F,0x49,0x69,0x3F,0x1E,0x00,0x00},      // 0x39
+        {0x00,0x00,0x6C,0x6C,0x00,0x00,0x00,0x00},      // 0x3A
+        {0x00,0xA0,0xEC,0x6C,0x00,0x00,0x00,0x00},      // 0x3B
+        {0x08,0x1C,0x36,0x63,0x41,0x00,0x00,0x00},      // 0x3C
+        {0x14,0x14,0x14,0x14,0x14,0x14,0x00,0x00},      // 0x3D
+        {0x00,0x41,0x63,0x36,0x1C,0x08,0x00,0x00},      // 0x3E
+        {0x02,0x03,0x51,0x59,0x0F,0x06,0x00,0x00},      // 0x3F
+        {0x3E,0x7F,0x41,0x5D,0x5D,0x1F,0x1E,0x00},      // 0x40
+        {0x7C,0x7E,0x13,0x13,0x7E,0x7C,0x00,0x00},      // 0x41
+        {0x41,0x7F,0x7F,0x49,0x49,0x7F,0x36,0x00},      // 0x42
+        {0x1C,0x3E,0x63,0x41,0x41,0x63,0x22,0x00},      // 0x43
+        {0x41,0x7F,0x7F,0x41,0x63,0x7F,0x1C,0x00},      // 0x44
+        {0x41,0x7F,0x7F,0x49,0x5D,0x41,0x63,0x00},      // 0x45
+        {0x41,0x7F,0x7F,0x49,0x1D,0x01,0x03,0x00},      // 0x46
+        {0x1C,0x3E,0x63,0x41,0x51,0x73,0x72,0x00},      // 0x47
+        {0x7F,0x7F,0x08,0x08,0x7F,0x7F,0x00,0x00},      // 0x48
+        {0x00,0x41,0x7F,0x7F,0x41,0x00,0x00,0x00},      // 0x49
+        {0x30,0x70,0x40,0x41,0x7F,0x3F,0x01,0x00},      // 0x4A
+        {0x41,0x7F,0x7F,0x08,0x1C,0x77,0x63,0x00},      // 0x4B
+        {0x41,0x7F,0x7F,0x41,0x40,0x60,0x70,0x00},      // 0x4C
+        {0x7F,0x7F,0x06,0x0C,0x06,0x7F,0x7F,0x00},      // 0x4D
+        {0x7F,0x7F,0x06,0x0C,0x18,0x7F,0x7F,0x00},      // 0x4E
+        {0x1C,0x3E,0x63,0x41,0x63,0x3E,0x1C,0x00},      // 0x4F
+        {0x41,0x7F,0x7F,0x49,0x09,0x0F,0x06,0x00},      // 0x50
+        {0x1E,0x3F,0x21,0x71,0x7F,0x5E,0x00,0x00},      // 0x51
+        {0x41,0x7F,0x7F,0x19,0x39,0x6F,0x46,0x00},      // 0x52
+        {0x26,0x67,0x4D,0x59,0x7B,0x32,0x00,0x00},      // 0x53
+        {0x03,0x41,0x7F,0x7F,0x41,0x03,0x00,0x00},      // 0x54
+        {0x7F,0x7F,0x40,0x40,0x7F,0x7F,0x00,0x00},      // 0x55
+        {0x1F,0x3F,0x60,0x60,0x3F,0x1F,0x00,0x00},      // 0x56
+        {0x7F,0x7F,0x30,0x18,0x30,0x7F,0x7F,0x00},      // 0x57
+        {0x63,0x77,0x1C,0x08,0x1C,0x77,0x63,0x00},      // 0x58
+        {0x07,0x4F,0x78,0x78,0x4F,0x07,0x00,0x00},      // 0x59
+        {0x67,0x73,0x59,0x4D,0x47,0x63,0x71,0x00},      // 0x5A
+        {0x00,0x7F,0x7F,0x41,0x41,0x00,0x00,0x00},      // 0x5B
+        {0x01,0x03,0x06,0x0C,0x18,0x30,0x60,0x00},      // 0x5C
+        {0x00,0x41,0x41,0x7F,0x7F,0x00,0x00,0x00},      // 0x5D
+        {0x08,0x0C,0x06,0x03,0x06,0x0C,0x08,0x00},      // 0x5E
+        {0x80,0x80,0x80,0x80,0x80,0x80,0x80,0x80},      // 0x5F
+        {0x00,0x00,0x03,0x07,0x04,0x00,0x00,0x00},      // 0x60
+        {0x20,0x74,0x54,0x54,0x3C,0x78,0x40,0x00},      // 0x61
+        {0x41,0x3F,0x7F,0x44,0x44,0x7C,0x38,0x00},      // 0x62
+        {0x38,0x7C,0x44,0x44,0x6C,0x28,0x00,0x00},      // 0x63
+        {0x30,0x78,0x48,0x49,0x3F,0x7F,0x40,0x00},      // 0x64
+        {0x38,0x7C,0x54,0x54,0x5C,0x18,0x00,0x00},      // 0x65
+        {0x48,0x7E,0x7F,0x49,0x03,0x02,0x00,0x00},      // 0x66
+        {0x98,0xBC,0xA4,0xA4,0xF8,0x7C,0x04,0x00},      // 0x67
+        {0x41,0x7F,0x7F,0x08,0x04,0x7C,0x78,0x00},      // 0x68
+        {0x00,0x44,0x7D,0x7D,0x40,0x00,0x00,0x00},      // 0x69
+        {0x40,0xC4,0x84,0xFD,0x7D,0x00,0x00,0x00},      // 0x6A
+        {0x41,0x7F,0x7F,0x10,0x38,0x6C,0x44,0x00},      // 0x6B
+        {0x00,0x41,0x7F,0x7F,0x40,0x00,0x00,0x00},      // 0x6C
+        {0x7C,0x7C,0x0C,0x18,0x0C,0x7C,0x78,0x00},      // 0x6D
+        {0x7C,0x7C,0x04,0x04,0x7C,0x78,0x00,0x00},      // 0x6E
+        {0x38,0x7C,0x44,0x44,0x7C,0x38,0x00,0x00},      // 0x6F
+        {0x84,0xFC,0xF8,0xA4,0x24,0x3C,0x18,0x00},      // 0x70
+        {0x18,0x3C,0x24,0xA4,0xF8,0xFC,0x84,0x00},      // 0x71
+        {0x44,0x7C,0x78,0x44,0x1C,0x18,0x00,0x00},      // 0x72
+        {0x48,0x5C,0x54,0x54,0x74,0x24,0x00,0x00},      // 0x73
+        {0x00,0x04,0x3E,0x7F,0x44,0x24,0x00,0x00},      // 0x74
+        {0x3C,0x7C,0x40,0x40,0x3C,0x7C,0x40,0x00},      // 0x75
+        {0x1C,0x3C,0x60,0x60,0x3C,0x1C,0x00,0x00},      // 0x76
+        {0x3C,0x7C,0x60,0x30,0x60,0x7C,0x3C,0x00},      // 0x77
+        {0x44,0x6C,0x38,0x10,0x38,0x6C,0x44,0x00},      // 0x78
+        {0x9C,0xBC,0xA0,0xA0,0xFC,0x7C,0x00,0x00},      // 0x79
+        {0x4C,0x64,0x74,0x5C,0x4C,0x64,0x00,0x00},      // 0x7A
+        {0x08,0x08,0x3E,0x77,0x41,0x41,0x00,0x00},      // 0x7B
+        {0x00,0x00,0x00,0x77,0x77,0x00,0x00,0x00},      // 0x7C
+        {0x41,0x41,0x77,0x3E,0x08,0x08,0x00,0x00},      // 0x7D
+        {0x02,0x03,0x01,0x03,0x02,0x03,0x01,0x00},      // 0x7E
+        {0x78,0x7C,0x46,0x43,0x46,0x7C,0x78,0x00},      // 0x7F
+        {0x1E,0xBF,0xE1,0x61,0x33,0x12,0x00,0x00},      // 0x80
+        {0x3A,0x7A,0x40,0x40,0x7A,0x7A,0x40,0x00},      // 0x81
+        {0x38,0x7C,0x56,0x57,0x5D,0x18,0x00,0x00},      // 0x82
+        {0x02,0x23,0x75,0x55,0x55,0x7D,0x7B,0x42},      // 0x83
+        {0x21,0x75,0x54,0x54,0x7D,0x79,0x40,0x00},      // 0x84
+        {0x20,0x75,0x57,0x56,0x7C,0x78,0x40,0x00},      // 0x85
+        {0x00,0x22,0x77,0x55,0x55,0x7F,0x7A,0x40},      // 0x86
+        {0x1C,0xBE,0xE2,0x62,0x36,0x14,0x00,0x00},      // 0x87
+        {0x02,0x3B,0x7D,0x55,0x55,0x5D,0x1B,0x02},      // 0x88
+        {0x39,0x7D,0x54,0x54,0x5D,0x19,0x00,0x00},      // 0x89
+        {0x38,0x7D,0x57,0x56,0x5C,0x18,0x00,0x00},      // 0x8A
+        {0x01,0x45,0x7C,0x7C,0x41,0x01,0x00,0x00},      // 0x8B
+        {0x02,0x03,0x45,0x7D,0x7D,0x43,0x02,0x00},      // 0x8C
+        {0x00,0x45,0x7F,0x7E,0x40,0x00,0x00,0x00},      // 0x8D
+        {0x79,0x7D,0x26,0x26,0x7D,0x79,0x00,0x00},      // 0x8E
+        {0x70,0x7A,0x2D,0x2D,0x7A,0x70,0x00,0x00},      // 0x8F
+        {0x44,0x7C,0x7E,0x57,0x55,0x44,0x00,0x00},      // 0x90
+        {0x20,0x74,0x54,0x54,0x7C,0x7C,0x54,0x54},      // 0x91
+        {0x7C,0x7E,0x0B,0x09,0x7F,0x7F,0x49,0x00},      // 0x92
+        {0x32,0x7B,0x49,0x49,0x7B,0x32,0x00,0x00},      // 0x93
+        {0x32,0x7A,0x48,0x48,0x7A,0x32,0x00,0x00},      // 0x94
+        {0x30,0x79,0x4B,0x4A,0x78,0x30,0x00,0x00},      // 0x95
+        {0x3A,0x7B,0x41,0x41,0x7B,0x7A,0x40,0x00},      // 0x96
+        {0x38,0x79,0x43,0x42,0x78,0x78,0x40,0x00},      // 0x97
+        {0xBA,0xBA,0xA0,0xA0,0xFA,0x7A,0x00,0x00},      // 0x98
+        {0x39,0x7D,0x44,0x44,0x44,0x7D,0x39,0x00},      // 0x99
+        {0x3D,0x7D,0x40,0x40,0x7D,0x3D,0x00,0x00},      // 0x9A
+        {0x38,0x7C,0x64,0x54,0x4C,0x7C,0x38,0x00},      // 0x9B
+        {0x68,0x7E,0x7F,0x49,0x43,0x66,0x20,0x00},      // 0x9C
+        {0x5C,0x3E,0x73,0x49,0x67,0x3E,0x1D,0x00},      // 0x9D
+        {0x44,0x6C,0x38,0x38,0x6C,0x44,0x00,0x00},      // 0x9E
+        {0x40,0xC8,0x88,0xFE,0x7F,0x09,0x0B,0x02},      // 0x9F
+        {0x20,0x74,0x56,0x57,0x7D,0x78,0x40,0x00},      // 0xA0
+        {0x00,0x44,0x7E,0x7F,0x41,0x00,0x00,0x00},      // 0xA1
+        {0x30,0x78,0x48,0x4A,0x7B,0x31,0x00,0x00},      // 0xA2
+        {0x38,0x78,0x40,0x42,0x7B,0x79,0x40,0x00},      // 0xA3
+        {0x7A,0x7B,0x09,0x0B,0x7A,0x73,0x01,0x00},      // 0xA4
+        {0x7A,0x7B,0x19,0x33,0x7A,0x7B,0x01,0x00},      // 0xA5
+        {0x00,0x26,0x2F,0x29,0x2F,0x2F,0x28,0x00},      // 0xA6
+        {0x00,0x26,0x2F,0x29,0x29,0x2F,0x26,0x00},      // 0xA7
+        {0x30,0x78,0x4D,0x45,0x60,0x20,0x00,0x00},      // 0xA8
+        {0x1C,0x22,0x7D,0x4B,0x5B,0x65,0x22,0x1C},      // 0xA9
+        {0x08,0x08,0x08,0x08,0x38,0x38,0x00,0x00},      // 0xAA
+        {0x61,0x3F,0x1F,0xCC,0xEE,0xAB,0xB9,0x90},      // 0xAB
+        {0x61,0x3F,0x1F,0x4C,0x66,0x73,0xD9,0xF8},      // 0xAC
+        {0x00,0x00,0x60,0xFA,0xFA,0x60,0x00,0x00},      // 0xAD
+        {0x08,0x1C,0x36,0x22,0x08,0x1C,0x36,0x22},      // 0xAE
+        {0x22,0x36,0x1C,0x08,0x22,0x36,0x1C,0x08},      // 0xAF
+        {0xAA,0x00,0x55,0x00,0xAA,0x00,0x55,0x00},      // 0xB0
+        {0xAA,0x55,0xAA,0x55,0xAA,0x55,0xAA,0x55},      // 0xB1
+        {0x55,0xFF,0xAA,0xFF,0x55,0xFF,0xAA,0xFF},      // 0xB2
+        {0x00,0x00,0x00,0xFF,0xFF,0x00,0x00,0x00},      // 0xB3
+        {0x10,0x10,0x10,0xFF,0xFF,0x00,0x00,0x00},      // 0xB4
+        {0x70,0x78,0x2C,0x2E,0x7B,0x71,0x00,0x00},      // 0xB5
+        {0x72,0x79,0x2D,0x2D,0x79,0x72,0x00,0x00},      // 0xB6
+        {0x71,0x7B,0x2E,0x2C,0x78,0x70,0x00,0x00},      // 0xB7
+        {0x1C,0x22,0x5D,0x55,0x55,0x41,0x22,0x1C},      // 0xB8
+        {0x14,0x14,0xF7,0xF7,0x00,0xFF,0xFF,0x00},      // 0xB9
+        {0x00,0x00,0xFF,0xFF,0x00,0xFF,0xFF,0x00},      // 0xBA
+        {0x14,0x14,0xF4,0xF4,0x04,0xFC,0xFC,0x00},      // 0xBB
+        {0x14,0x14,0x17,0x17,0x10,0x1F,0x1F,0x00},      // 0xBC
+        {0x18,0x3C,0x24,0xE7,0xE7,0x24,0x24,0x00},      // 0xBD
+        {0x2B,0x2F,0xFC,0xFC,0x2F,0x2B,0x00,0x00},      // 0xBE
+        {0x10,0x10,0x10,0xF0,0xF0,0x00,0x00,0x00},      // 0xBF
+        {0x00,0x00,0x00,0x1F,0x1F,0x10,0x10,0x10},      // 0xC0
+        {0x10,0x10,0x10,0x1F,0x1F,0x10,0x10,0x10},      // 0xC1
+        {0x10,0x10,0x10,0xF0,0xF0,0x10,0x10,0x10},      // 0xC2
+        {0x00,0x00,0x00,0xFF,0xFF,0x10,0x10,0x10},      // 0xC3
+        {0x10,0x10,0x10,0x10,0x10,0x10,0x10,0x10},      // 0xC4
+        {0x10,0x10,0x10,0xFF,0xFF,0x10,0x10,0x10},      // 0xC5
+        {0x22,0x77,0x55,0x57,0x7E,0x7B,0x41,0x00},      // 0xC6
+        {0x72,0x7B,0x2D,0x2F,0x7A,0x73,0x01,0x00},      // 0xC7
+        {0x00,0x00,0x1F,0x1F,0x10,0x17,0x17,0x14},      // 0xC8
+        {0x00,0x00,0xFC,0xFC,0x04,0xF4,0xF4,0x14},      // 0xC9
+        {0x14,0x14,0x17,0x17,0x10,0x17,0x17,0x14},      // 0xCA
+        {0x14,0x14,0xF4,0xF4,0x04,0xF4,0xF4,0x14},      // 0xCB
+        {0x00,0x00,0xFF,0xFF,0x00,0xF7,0xF7,0x14},      // 0xCC
+        {0x14,0x14,0x14,0x14,0x14,0x14,0x14,0x14},      // 0xCD
+        {0x14,0x14,0xF7,0xF7,0x00,0xF7,0xF7,0x14},      // 0xCE
+        {0x66,0x3C,0x3C,0x24,0x3C,0x3C,0x66,0x00},      // 0xCF
+        {0x05,0x27,0x72,0x57,0x7D,0x38,0x00,0x00},      // 0xD0
+        {0x49,0x7F,0x7F,0x49,0x63,0x7F,0x1C,0x00},      // 0xD1
+        {0x46,0x7D,0x7D,0x55,0x55,0x46,0x00,0x00},      // 0xD2
+        {0x45,0x7D,0x7C,0x54,0x55,0x45,0x00,0x00},      // 0xD3
+        {0x44,0x7D,0x7F,0x56,0x54,0x44,0x00,0x00},      // 0xD4
+        {0x0A,0x0E,0x08,0x00,0x00,0x00,0x00,0x00},      // 0xD5
+        {0x00,0x44,0x7E,0x7F,0x45,0x00,0x00,0x00},      // 0xD6
+        {0x02,0x45,0x7D,0x7D,0x45,0x02,0x00,0x00},      // 0xD7
+        {0x01,0x45,0x7C,0x7C,0x45,0x01,0x00,0x00},      // 0xD8
+        {0x10,0x10,0x10,0x1F,0x1F,0x00,0x00,0x00},      // 0xD9
+        {0x00,0x00,0x00,0xF0,0xF0,0x10,0x10,0x10},      // 0xDA
+        {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF},      // 0xDB
+        {0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0,0xF0},      // 0xDC
+        {0x00,0x00,0x00,0x77,0x77,0x00,0x00,0x00},      // 0xDD
+        {0x00,0x45,0x7F,0x7E,0x44,0x00,0x00,0x00},      // 0xDE
+        {0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F,0x0F},      // 0xDF
+        {0x38,0x7C,0x46,0x47,0x45,0x7C,0x38,0x00},      // 0xE0
+        {0xFC,0xFE,0x2A,0x2A,0x3E,0x14,0x00,0x00},      // 0xE1
+        {0x3A,0x7D,0x45,0x45,0x45,0x7D,0x3A,0x00},      // 0xE2
+        {0x38,0x7C,0x45,0x47,0x46,0x7C,0x38,0x00},      // 0xE3
+        {0x32,0x7B,0x49,0x4B,0x7A,0x33,0x01,0x00},      // 0xE4
+        {0x3A,0x7F,0x45,0x47,0x46,0x7F,0x39,0x00},      // 0xE5
+        {0x80,0xFE,0x7E,0x20,0x20,0x3E,0x1E,0x00},      // 0xE6
+        {0x42,0x7E,0x7E,0x54,0x1C,0x08,0x00,0x00},      // 0xE7
+        {0x41,0x7F,0x7F,0x55,0x14,0x1C,0x08,0x00},      // 0xE8
+        {0x3C,0x7C,0x42,0x43,0x7D,0x3C,0x00,0x00},      // 0xE9
+        {0x3A,0x79,0x41,0x41,0x79,0x3A,0x00,0x00},      // 0xEA
+        {0x3C,0x7D,0x43,0x42,0x7C,0x3C,0x00,0x00},      // 0xEB
+        {0xB8,0xB8,0xA2,0xA3,0xF9,0x78,0x00,0x00},      // 0xEC
+        {0x0C,0x5C,0x72,0x73,0x5D,0x0C,0x00,0x00},      // 0xED
+        {0x02,0x02,0x02,0x02,0x02,0x02,0x00,0x00},      // 0xEE
+        {0x00,0x00,0x02,0x03,0x01,0x00,0x00,0x00},      // 0xEF
+        {0x10,0x10,0x10,0x10,0x10,0x10,0x00,0x00},      // 0xF0
+        {0x44,0x44,0x5F,0x5F,0x44,0x44,0x00,0x00},      // 0xF1
+        {0x28,0x28,0x28,0x28,0x28,0x28,0x00,0x00},      // 0xF2
+        {0x71,0x35,0x1F,0x4C,0x66,0x73,0xD9,0xF8},      // 0xF3
+        {0x06,0x0F,0x09,0x7F,0x7F,0x01,0x7F,0x7F},      // 0xF4
+        {0xDA,0xBF,0xA5,0xA5,0xFD,0x59,0x03,0x02},      // 0xF5
+        {0x08,0x08,0x6B,0x6B,0x08,0x08,0x00,0x00},      // 0xF6
+        {0x00,0x80,0xC0,0x40,0x00,0x00,0x00,0x00},      // 0xF7
+        {0x00,0x06,0x0F,0x09,0x0F,0x06,0x00,0x00},      // 0xF8
+        {0x02,0x02,0x00,0x00,0x02,0x02,0x00,0x00},      // 0xF9
+        {0x00,0x00,0x00,0x10,0x10,0x00,0x00,0x00},      // 0xFA
+        {0x00,0x12,0x13,0x1F,0x1F,0x10,0x10,0x00},      // 0xFB
+        {0x00,0x11,0x15,0x15,0x1F,0x1F,0x0A,0x00},      // 0xFC
+        {0x00,0x19,0x1D,0x15,0x17,0x12,0x00,0x00},      // 0xFD
+        {0x00,0x00,0x3C,0x3C,0x3C,0x3C,0x00,0x00},      // 0xFE
+        {0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}       // 0xFF
+};

 /Transportables_Koptertool/trunk/font8x8.h
 ,0 → 1,19
+/*
+ *  font8x8.h
+ *  LCD-OSD
+ *
+ *  Created by Peter Mack on 26.12.09.
+ *  Copyright 2009 SCS GmbH & Co. KG. All rights reserved.
+ *
+ */
+#ifndef _FONT8X8_H
+#define _FONT8X8_H
+#include <avr/pgmspace.h>
+//*****************************************************************************
+//
+extern prog_uint8_t font8x8[256][8];
+#endif

 /Transportables_Koptertool/trunk/jeti.c
 ,0 → 1,260
+/*****************************************************************************
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   see this fine thread on RCLine:                                         *
+ *   http://www.rclineforum.de/forum/thread.php?threadid=226786              *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include "main.h"               // LEDs
+#include "timer.h"      // Keys
+#include "lcd.h"
+#include "jeti.h"
+#define font8x8
+uint8_t JetiBuffer[32]; // 32 characters
+volatile uint8_t JetiBufferReady;
+//*****************************************************************************
+//
+ISR (USART1_RX_vect)
+{
+        uint8_t stat;
+        uint8_t rh;
+        uint8_t rl;
+        static uint8_t jbp;
+        stat = UCSR1A;
+        rh = UCSR1B;
+        rl = UDR1;
+        if (stat & ((1 << FE1) | (1 << DOR1) | (1 << UPE1)))
+        {       // discard buffer and start new on any error
+                JetiBufferReady = 0;
+                jbp = 0;
+                                                                                                                  //1234567890123456
+                lcd_printpj_at (0, 3, PSTR(" Communication  "), 0);
+                lcd_printpj_at (0, 4, PSTR("    Error       "), 0);
+                LED6_TOGGLE;
+        }
+        else if ((rh & (1 << RXB81)) == 0)
+        {       // control
+                if (rl == 0xfe)
+                {       // start condition
+                        JetiBufferReady = 0;
+                        jbp = 0;
+                        LED1_ON;
+                }
+                else if (rl == 0xff)
+                {       // stop condition
+                        JetiBufferReady = 1;
+                        LED1_OFF;
+                }
+        }
+        else
+        {       // data
+                if (jbp < 32)
+                {
+                        JetiBuffer[jbp++] = rl;
+                }
+        }
+}
+//*****************************************************************************
+//
+void JETI_Init (void)
+{
+        DDRD  &= ~(1 << DDD3);          // set TXD1 pin as input
+        PORTD &= ~(1 << PORTD3);        // disable pullup on TXD1 pin
+        // set clock divider
+#undef BAUD
+#define BAUD 9600
+#include <util/setbaud.h>
+        UBRR1H = UBRRH_VALUE;
+        UBRR1L = UBRRL_VALUE;
+#if USE_2X
+        UCSR1A |= (1 << U2X1);  // enable double speed operation
+#else
+        UCSR1A &= ~(1 << U2X1); // disable double speed operation
+#endif
+        // set 9O1
+        UCSR1C = (1 << UPM11) | (1 << UPM10) | (1 << UCSZ11) | (1 << UCSZ10);
+        UCSR1B = (1 << UCSZ12);
+        // flush receive buffer
+        while ( UCSR1A & (1 << RXC1) ) UDR1;
+}
+//*****************************************************************************
+// disable the txd pin of usart
+void JETI_DisableTXD (void)
+{
+        UCSR1B &= ~(1 << TXEN1);        // disable TX}
+}
+//*****************************************************************************
+// enable the txd pin of usart
+void JETI_EnableTXD (void)
+{
+        UCSR1B |=  (1 << TXEN1);        // enable TX
+}
+//*****************************************************************************
+//
+void JETI_putw (uint16_t c)
+{
+        loop_until_bit_is_set(UCSR1A, UDRE1);
+        UCSR1B &= ~(1 << TXB81);
+        if (c & 0x0100)
+        {
+                UCSR1B |= (1 << TXB81);
+        }
+        UDR1 = c;
+}
+//*****************************************************************************
+//
+void JETI_putc (uint8_t c)
+{
+        loop_until_bit_is_set(UCSR1A, UDRE1);
+        //      UCSRB &= ~(1 << TXB8);
+        UCSR1B |= (1 << TXB81);
+        UDR1 = c;
+}
+//*****************************************************************************
+//
+void JETI_puts (char *s)
+{
+        while (*s)
+        {
+                JETI_putc (*s);
+                s++;
+        }
+}
+//*****************************************************************************
+//
+void JETI_puts_p (const char *s)
+{
+        while (pgm_read_byte(s))
+        {
+                JETI_putc (pgm_read_byte(s));
+                s++;
+        }
+}
+//*****************************************************************************
+//
+void JETI_put_start (void)
+{
+        loop_until_bit_is_set(UCSR1A, UDRE1);
+        UCSR1B &= ~(1 << TXB81);
+        UDR1 = 0xFE;
+}
+//*****************************************************************************
+//
+void JETI_put_stop (void)
+{
+        loop_until_bit_is_set(UCSR1A, UDRE1);
+        UCSR1B &= ~(1 << TXB81);
+        UDR1 = 0xFF;
+}
+//*****************************************************************************
+//
+void jeti (void)
+{
+        uint8_t key;
+        uint8_t i;
+        // enable Rx
+        UCSR1B |= (1 << RXEN1);
+        UCSR1B |= (1 << RXCIE1);
+        lcd_cls ();
+        lcd_printp_at (0, 0, PSTR("Jeti Box Display"), 0);
+        lcd_printpns_at (0, 7, PSTR(" \x1a    \x1b      \x1c     \x1d"), 0);
+#ifdef font8x8
+        lcd_line(0, 21, 127, 21, 1);
+        lcd_line(0, 22, 127, 22, 1);
+        lcd_line(0, 40, 127, 40, 1);
+        lcd_line(0, 41, 127, 41, 1);
+#else
+        lcd_rect(10, 22, 98, 18, 1);
+#endif
+        do
+        {
+                if (JetiBufferReady)
+                {
+                        JETI_EnableTXD();
+                        LED2_ON;
+                        for (i = 0; i < 16; i++)
+                        {
+#ifdef font8x8
+                                lcd_putc_jeti(i, 3, JetiBuffer[i], 0);
+#else
+                                lcd_putc (2 + i, 3, JetiBuffer[i], 0);
+#endif
+                        }
+                        for (i = 0; i < 16; i++)
+                        {
+#ifdef font8x8
+                                lcd_putc_jeti(i, 4, JetiBuffer[i + 16], 0);
+#else
+                                lcd_putc (2 + i, 4, JetiBuffer[i + 16], 0);
+#endif
+                        }
+                        JetiBufferReady = 0;    // invalidate buffer
+                        LED2_OFF;
+                        _delay_ms (1);  //
+                                                                                                // Writing to the display takes aprox. 5.8 ms @ 7 MHz and 3.2 ms @ 20 MHz.
+                                                                                                // With the additional 4 ms we had a 10 ms delay.
+                                                                                                // 10 ms works perfect with the MUI30 and the MT125
+                                                                                                // But not with the TU transceiver module.
+                        key = get_key_short ((1 << KEY_MINUS) | (1 << KEY_PLUS) | (1 << KEY_ESC) | (1 << KEY_ENTER));
+                        key = (key << 1) | (key >> 3);
+                        key = (~key) & 0xf0;
+                        JETI_putw((uint16_t) key);
+                        _delay_ms (1);
+                        JETI_DisableTXD();
+                }
+        }
+        while (!get_key_long (1 << KEY_ESC));
+        get_key_press(KEY_ALL);
+        // disable Rx
+        UCSR1B &= ~(1 << RXCIE1);
+        UCSR1B &= ~(1 << RXEN1);
+}

 /Transportables_Koptertool/trunk/jeti.h
 ,0 → 1,40
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   see this fine thread on RCLine:                                         *
+ *   http://www.rclineforum.de/forum/thread.php?threadid=226786              *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _JETI_H
+#define _JETI_H
+//*****************************************************************************
+//
+void JETI_Init (void);
+void JETI_DisableTXD (void);
+void JETI_EnableTXD (void);
+void JETI_putw (uint16_t c);
+void JETI_putc (uint8_t c);
+void JETI_puts (char *s);
+void JETI_puts_p (const char *s);
+void JETI_put_start (void);
+void JETI_put_stop (void);
+void jeti (void);
+#endif

 /Transportables_Koptertool/trunk/lcd.c
 ,0 → 1,1158
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   - original LCD control by Thomas "thkais" Kaiser                        *
+ *   - special number formating routines taken from C-OSD                    *
+ *      from Claas Anders "CaScAdE" Rathje                                   *
+ *   - some extension, ellipse and circ_line by Peter "woggle" Mack          *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include "font8x6.h"
+#ifndef USE_MMT
+#include "font8x8.h"
+#endif
+#include "main.h"
+#include "lcd.h"
+#define DISP_W 128
+#define DISP_H 64
+#define DISP_BUFFER ((DISP_H * DISP_W) / 8)
+volatile uint8_t display_buffer[DISP_BUFFER];   // Display-Puffer, weil nicht zurückgelesen werden kann
+volatile uint16_t display_buffer_pointer;                       // Pointer auf das aktuell übertragene Byte
+volatile uint8_t display_buffer_counter;                        // Hilfszähler zur Selektierung der Page
+volatile uint8_t display_page_counter;                          // aktuelle Page-Nummer
+volatile uint8_t display_mode;                                                          // Modus für State-Machine
+volatile uint8_t LCD_ORIENTATION;
+// DOG: 128 x 64 with 6x8 Font => 21 x 8
+// MAX7456: 30 x 16
+uint8_t lcd_xpos;
+uint8_t lcd_ypos;
+void send_byte (uint8_t data)
+{
+        clr_cs ();
+        SPDR = data;
+        while (!(SPSR & (1<<SPIF)));
+        //SPSR = SPSR;
+        set_cs ();
+}
+void lcd_cls (void)
+{
+        uint16_t i, j;
+//      memset (display_buffer, 0, 1024);
+        for (i = 0; i < DISP_BUFFER; i++)
+                display_buffer[i] = 0x00;
+        for (i = 0; i < 8; i++)
+        {
+                clr_A0 ();
+                send_byte (0xB0 + i);   //1011xxxx
+                send_byte (0x10);                       //00010000
+//              send_byte(0x04);                //00000100 gedreht plus 4 Byte
+//              send_byte(0x00);                //00000000
+                send_byte (LCD_ORIENTATION);    //00000000
+                set_A0 ();
+                for (j = 0; j < 128; j++)
+                        send_byte (0x00);
+        }
+        lcd_xpos = 0;
+        lcd_ypos = 0;
+}
+void wait_1ms (void)
+{
+        _delay_ms (1.0);
+}
+void wait_ms (uint16_t time)
+{
+        uint16_t i;
+        for (i = 0; i < time; i++)
+                wait_1ms ();
+}
+void LCD_Init (void)
+{
+        lcd_xpos = 0;
+        lcd_ypos = 0;
+        DDRB = 0xFF;
+        // SPI max. speed
+        // the DOGM128 lcd controller can work at 20 MHz
+        SPCR = (1 << SPE) | (1 << MSTR) | (1 << CPHA) | (1 << CPOL);
+        SPSR = (1 << SPI2X);
+        set_cs ();
+        clr_reset ();
+        wait_ms (10);
+        set_reset ();
+        clr_cs ();
+        clr_A0 ();
+        send_byte (0x40);
+        if (LCD_ORIENTATION == 0)
+        {
+                send_byte (0xA1); // A1 normal A0 reverse(original)
+                send_byte (0xC0); // C0 normal C8 reverse(original)
+        }
+        else
+        {
+                send_byte (0xA0); // A1 normal A0 reverse(original)
+                send_byte (0xC8); // C0 normal C8 reverse(original)
+        }
+        send_byte (0xA6);
+        send_byte (0xA2);
+        send_byte (0x2F);
+        send_byte (0xF8);
+        send_byte (0x00);
+        send_byte (0x27);
+        send_byte (0x81);
+        send_byte (0x16);
+        send_byte (0xAC);
+        send_byte (0x00);
+        send_byte (0xAF);
+        lcd_cls ();
+}
+void set_adress (uint16_t adress, uint8_t data)
+{
+        uint8_t page;
+        uint8_t column;
+        page = adress >> 7;
+        clr_A0 ();
+        send_byte (0xB0 + page);
+//      column = (adress & 0x7F) + 4; Wenn gedreht
+//      column = (adress & 0x7F);
+        column = (adress & 0x7F) + LCD_ORIENTATION;
+        send_byte (0x10 + (column >> 4));
+        send_byte (column & 0x0F);
+        set_A0 ();
+        send_byte (data);
+}
+void scroll (void)
+{
+        uint16_t adress;
+        for (adress = 0; adress < 896; adress++)
+        {
+                display_buffer[adress] = display_buffer[adress + 128];
+                set_adress (adress, display_buffer[adress]);
+        }
+        for (adress = 896; adress < 1024; adress++)
+        {
+                display_buffer[adress] = 0;
+                set_adress (adress, 0);
+        }
+}
+//
+// x,y = character-Pos. !
+//
+// mode: 0=Overwrite, 1 = OR, 2 = XOR, 3 = AND, 4 = Delete
+void lcd_putc (uint8_t x, uint8_t y, uint8_t c, uint8_t mode)
+{
+        uint8_t ch;
+        uint8_t i;
+        uint16_t adress;
+        switch (c)
+        {       // ISO 8859-1
+                case 0xc4:      // Ä
+                        c = 0x00;
+                        break;
+                case 0xe4:      // ä
+                        c = 0x01;
+                        break;
+                case 0xd6:      // Ö
+                        c = 0x02;
+                        break;
+                case 0xf6:      // ö
+                        c = 0x03;
+                        break;
+                case 0xdc:      // Ü
+                        c = 0x04;
+                        break;
+                case 0xfc:      // ü
+                        c = 0x05;
+                        break;
+                case 0xdf:      // ß
+                        //c = 0x06;
+                        c = 0x1e; // ° (used by Jeti)
+                        break;
+        }
+        c &= 0x7f;
+        adress = y * 128 + x * 6;
+        adress &= 0x3FF;
+        for (i = 0; i < 6; i++)
+        {
+                ch = pgm_read_byte (&font8x6[0][0] + i + c * 6);
+                switch (mode)
+                {
+                        case 0:
+                                display_buffer[adress+i] = ch;
+                                break;
+                        case 1:
+                                display_buffer[adress+i] |= ch;
+                                break;
+                        case 2:
+                                display_buffer[adress+i] ^= ch;
+                                break;
+                        case 3:
+                                display_buffer[adress+i] &= ch;
+                                break;
+                        case 4:
+                                display_buffer[adress+i] &= ~ch;
+                                break;
+                }
+                set_adress (adress + i, display_buffer[adress + i]);
+        }
+}
+#ifndef USE_MMT
+void lcd_putc_jeti (uint8_t x, uint8_t y, uint8_t c, uint8_t mode)
+{
+        uint8_t ch;
+        uint8_t i;
+        uint16_t adress;
+        switch (c)
+        {
+                case 0x7e:
+                        c = 0x1a; // ->
+                        break;
+                case 0x7f:
+                        c = 0x1b; // <-
+                        break;
+                case 0xdf:
+                        c = 0xf8; // °
+                        break;
+        }
+        adress = y * 128 + x * 8;
+        adress &= 0x3FF;
+        for (i = 0; i < 8; i++)
+        {
+                ch = pgm_read_byte (&font8x8[0][0] + i + c * 8);
+                switch (mode)
+                {
+                        case 0:
+                                display_buffer[adress+i] = ch;
+                                break;
+                        case 1:
+                                display_buffer[adress+i] |= ch;
+                                break;
+                        case 2:
+                                display_buffer[adress+i] ^= ch;
+                                break;
+                        case 3:
+                                display_buffer[adress+i] &= ch;
+                                break;
+                        case 4:
+                                display_buffer[adress+i] &= ~ch;
+                                break;
+                }
+                set_adress (adress + i, display_buffer[adress + i]);
+        }
+}
+#endif
+void new_line (void)
+{
+        lcd_ypos++;
+        if (lcd_ypos > 7)
+        {
+                scroll ();
+                lcd_ypos = 7;
+        }
+}
+#ifndef USE_MMT
+void lcd_printpj (const char *text, uint8_t mode)
+{
+        while (pgm_read_byte(text))
+        {
+                switch (pgm_read_byte(text))
+                {
+                        case 0x0D:
+                                lcd_xpos = 0;
+                                break;
+                        case 0x0A:
+                                new_line();
+                                break;
+                        default:
+                                lcd_putc_jeti (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
+                                lcd_xpos++;
+                                if (lcd_xpos > 20)
+                                {
+                                        lcd_xpos = 0;
+                                        new_line ();
+                                }
+                                break;
+                }
+                text++;
+        }
+}
+void lcd_printpj_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_printpj (text, mode);
+}
+#endif
+void lcd_printpns (const char *text, uint8_t mode)
+{
+        while (pgm_read_byte(text))
+        {
+                switch (pgm_read_byte(text))
+                {
+                        case 0x0D:
+                                lcd_xpos = 0;
+                                break;
+                        case 0x0A:
+                                new_line();
+                                break;
+                        default:
+                                lcd_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
+                                lcd_xpos++;
+                                if (lcd_xpos > 20)
+                                {
+                                        lcd_xpos = 0;
+//                                      new_line ();
+                                }
+                                break;
+                }
+                text++;
+        }
+}
+void lcd_printpns_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_printpns (text, mode);
+}
+void lcd_printp (const char *text, uint8_t mode)
+{
+        while (pgm_read_byte(text))
+        {
+                switch (pgm_read_byte(text))
+                {
+                        case 0x0D:
+                                lcd_xpos = 0;
+                                break;
+                        case 0x0A:
+                                new_line();
+                                break;
+                        default:
+                                lcd_putc (lcd_xpos, lcd_ypos, pgm_read_byte(text), mode);
+                                lcd_xpos++;
+                                if (lcd_xpos > 20)
+                                {
+                                        lcd_xpos = 0;
+                                        new_line ();
+                                }
+                                break;
+                }
+                text++;
+        }
+}
+void lcd_printp_at (uint8_t x, uint8_t y, const char *text, uint8_t mode)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_printp (text, mode);
+}
+void lcd_print (uint8_t *text, uint8_t mode)
+{
+        while (*text)
+        {
+                switch (*text)
+                {
+                        case 0x0D:
+                                lcd_xpos = 0;
+                                break;
+                        case 0x0A:
+                                new_line();
+                                break;
+                        default:
+                                lcd_putc (lcd_xpos, lcd_ypos, *text, mode);
+                                lcd_xpos++;
+                                if (lcd_xpos > 20)
+                                {
+                                        lcd_xpos = 0;
+                                        new_line ();
+                                }
+                                break;
+                }
+                text++;
+        }
+}
+void lcd_print_at (uint8_t x, uint8_t y, uint8_t *text, uint8_t mode)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_print (text, mode);
+}
+void print_display (uint8_t *text)
+{
+        while (*text)
+        {
+                lcd_putc (lcd_xpos, lcd_ypos, *text, 0);
+                lcd_xpos++;
+                if (lcd_xpos >= 20)
+                {
+                        lcd_xpos = 0;
+                        new_line ();
+                }
+                text++;
+        }
+}
+void print_display_at (uint8_t x, uint8_t y, uint8_t *text)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        print_display (text);
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + Plot (set one Pixel)
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// mode:
+// 0=Clear, 1=Set, 2=XOR
+void lcd_plot (uint8_t xpos, uint8_t ypos, uint8_t mode)
+{
+        uint16_t adress;
+        uint8_t mask;
+        if ((xpos < DISP_W) && (ypos < DISP_H))
+        {
+                adress = (ypos / 8) * DISP_W + xpos;            // adress = 0/8 * 128 + 0   = 0
+                mask = 1 << (ypos & 0x07);                                      // mask = 1<<0 = 1
+                adress &= DISP_BUFFER - 1;
+                switch (mode)
+                {
+                        case 0:
+                                display_buffer[adress] &= ~mask;
+                                break;
+                        case 1:
+                                display_buffer[adress] |= mask;
+                                break;
+                        case 2:
+                                display_buffer[adress] ^= mask;
+                                break;
+                }
+                set_adress (adress, display_buffer[adress]);
+        }
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + Line (draws a line from x1,y1 to x2,y2
+// + Based on Bresenham line-Algorithm
+// + found in the internet, modified by thkais 2007
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void lcd_line (unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, uint8_t mode)
+{
+        int x, y, count, xs, ys, xm, ym;
+        x = (int) x1;
+        y = (int) y1;
+        xs = (int) x2 - (int) x1;
+        ys = (int) y2 - (int) y1;
+        if (xs < 0)
+                xm = -1;
+        else
+                if (xs > 0)
+                        xm = 1;
+                else
+                        xm = 0;
+        if (ys < 0)
+                ym = -1;
+        else
+                if (ys > 0)
+                        ym = 1;
+                else
+                        ym = 0;
+        if (xs < 0)
+                xs = -xs;
+        if (ys < 0)
+                ys = -ys;
+        lcd_plot ((unsigned char) x, (unsigned char) y, mode);
+        if (xs > ys) // Flat Line <45 degrees
+        {
+                count = -(xs / 2);
+                while (x != x2)
+                {
+                        count = count + ys;
+                        x = x + xm;
+                        if (count > 0)
+                        {
+                                y = y + ym;
+                                count = count - xs;
+                        }
+                        lcd_plot ((unsigned char) x, (unsigned char) y, mode);
+                }
+        }
+        else // Line >=45 degrees
+        {
+                count =- (ys / 2);
+                while (y != y2)
+                {
+                        count = count + xs;
+                        y = y + ym;
+                        if (count > 0)
+                        {
+                                x = x + xm;
+                                count = count - ys;
+                        }
+                        lcd_plot ((unsigned char) x, (unsigned char) y, mode);
+                }
+        }
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + Filled rectangle
+// + x1, y1 = upper left corner
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void lcd_frect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)
+{
+        uint16_t x2, y2;
+        uint16_t i;
+        if (x1 >= DISP_W)
+                x1 = DISP_W - 1;
+        if (y1 >= DISP_H)
+                y1 = DISP_H - 1;
+        x2 = x1 + widthx;
+        y2 = y1 + widthy;
+        if (x2 > DISP_W)
+                x2 = DISP_W;
+        if (y2 > DISP_H)
+                y2 = DISP_H;
+        for (i = y1; i <= y2; i++)
+        {
+                lcd_line (x1, i, x2, i, mode);
+        }
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + outline of rectangle
+// + x1, y1 = upper left corner
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void lcd_rect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode)
+{
+        uint16_t x2, y2;
+        if (x1 >= DISP_W)
+                x1 = DISP_W - 1;
+        if (y1 >= DISP_H)
+                y1 = DISP_H - 1;
+        x2 = x1 + widthx;
+        y2 = y1 + widthy;
+        if (x2 > DISP_W)
+                x2 = DISP_W;
+        if (y2 > DISP_H)
+                y2 = DISP_H;
+        lcd_line (x1, y1, x2, y1, mode);
+        lcd_line (x2, y1, x2, y2, mode);
+        lcd_line (x2, y2, x1, y2, mode);
+        lcd_line (x1, y2, x1, y1, mode);
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + outline of a circle
+// + Based on Bresenham-algorithm found in wikipedia
+// + modified by thkais (2007)
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void lcd_circle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode)
+{
+        int16_t f = 1 - radius;
+        int16_t ddF_x = 0;
+        int16_t ddF_y = -2 * radius;
+        int16_t x = 0;
+        int16_t y = radius;
+        lcd_plot (x0, y0 + radius, mode);
+        lcd_plot (x0, y0 - radius, mode);
+        lcd_plot (x0 + radius, y0, mode);
+        lcd_plot (x0 - radius, y0, mode);
+        while (x < y)
+        {
+                if (f >= 0)
+                {
+                        y --;
+                        ddF_y += 2;
+                        f += ddF_y;
+                }
+                x ++;
+                ddF_x += 2;
+                f += ddF_x + 1;
+                lcd_plot (x0 + x, y0 + y, mode);
+                lcd_plot (x0 - x, y0 + y, mode);
+                lcd_plot (x0 + x, y0 - y, mode);
+                lcd_plot (x0 - x, y0 - y, mode);
+                lcd_plot (x0 + y, y0 + x, mode);
+                lcd_plot (x0 - y, y0 + x, mode);
+                lcd_plot (x0 + y, y0 - x, mode);
+                lcd_plot (x0 - y, y0 - x, mode);
+        }
+}
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+// + filled Circle
+// + modified circle-algorithm thkais (2007)
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+void lcd_fcircle (int16_t x0, int16_t y0, int16_t radius)
+{
+        int16_t f = 1 - radius;
+        int16_t ddF_x = 0;
+        int16_t ddF_y = -2 * radius;
+        int16_t x = 0;
+        int16_t y = radius;
+        lcd_line (x0, y0 + radius, x0, y0 - radius, 1);
+        lcd_line (x0 + radius, y0, x0 - radius, y0, 1);
+        while (x < y)
+        {
+                if (f >= 0)
+                {
+                        y--;
+                        ddF_y += 2;
+                        f += ddF_y;
+                }
+                x++;
+                ddF_x += 2;
+                f += ddF_x + 1;
+                lcd_line (x0 + x, y0 + y, x0 - x, y0 + y, 1);
+                lcd_line (x0 + x, y0 - y, x0 - x, y0 - y, 1);
+                lcd_line (x0 + y, y0 + x, x0 - y, y0 + x, 1);
+                lcd_line (x0 + y, y0 - x, x0 - y, y0 - x, 1);
+        }
+}
+//*****************************************************************************
+//
+void lcd_circ_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode)
+{
+        uint8_t xc, yc;
+        double deg_rad;
+        deg_rad = (deg * M_PI) / 180.0;
+        yc = y - (uint8_t) round (cos (deg_rad) * (double) r);
+        xc = x + (uint8_t) round (sin (deg_rad) * (double) r);
+        lcd_line (x, y, xc, yc, mode);
+}
+//*****************************************************************************
+//
+void lcd_ellipse_line (uint8_t x, uint8_t y, uint8_t rx, uint8_t ry, uint16_t deg, uint8_t mode)
+{
+        uint8_t xc, yc;
+        double deg_rad;
+        deg_rad = (deg * M_PI) / 180.0;
+        yc = y - (uint8_t) round (cos (deg_rad) * (double) ry);
+        xc = x + (uint8_t) round (sin (deg_rad) * (double) rx);
+        lcd_line (x, y, xc, yc, mode);
+}
+//*****************************************************************************
+//
+void lcd_ellipse (int16_t x0, int16_t y0, int16_t rx, int16_t ry, uint8_t mode)
+{
+        const int16_t rx2 = rx * rx;
+        const int16_t ry2 = ry * ry;
+        int16_t F = round (ry2 - rx2 * ry + 0.25 * rx2);
+        int16_t ddF_x = 0;
+        int16_t ddF_y = 2 * rx2 * ry;
+        int16_t x = 0;
+        int16_t y = ry;
+        lcd_plot (x0, y0 + ry, mode);
+        lcd_plot (x0, y0 - ry, mode);
+        lcd_plot (x0 + rx, y0, mode);
+        lcd_plot (x0 - rx, y0, mode);
+        // while ( 2*ry2*x < 2*rx2*y ) {  we can use ddF_x and ddF_y
+        while (ddF_x < ddF_y)
+        {
+                if(F >= 0)
+                {
+                        y     -= 1;        // south
+                        ddF_y -= 2 * rx2;
+                        F     -= ddF_y;
+                }
+                x     += 1;          // east
+                ddF_x += 2 * ry2;
+                F     += ddF_x + ry2;
+                lcd_plot (x0 + x, y0 + y, mode);
+                lcd_plot (x0 + x, y0 - y, mode);
+                lcd_plot (x0 - x, y0 + y, mode);
+                lcd_plot (x0 - x, y0 - y, mode);
+        }
+        F = round (ry2 * (x + 0.5) * (x + 0.5) + rx2 * (y - 1) * (y - 1) - rx2 * ry2);
+        while(y > 0)
+        {
+                if(F <= 0)
+                {
+                        x     += 1;        // east
+                        ddF_x += 2 * ry2;
+                        F     += ddF_x;
+                }
+                y     -=1;           // south
+                ddF_y -= 2 * rx2;
+                F     += rx2 - ddF_y;
+                lcd_plot (x0 + x, y0 + y, mode);
+                lcd_plot (x0 + x, y0 - y, mode);
+                lcd_plot (x0 - x, y0 + y, mode);
+                lcd_plot (x0 - x, y0 - y, mode);
+        }
+}
+//*****************************************************************************
+//
+void lcd_ecircle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode)
+{
+        lcd_ellipse (x0, y0, radius + 3, radius, mode);
+}
+//*****************************************************************************
+//
+void lcd_ecirc_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode)
+{
+        lcd_ellipse_line(x, y, r + 3, r, deg, mode);
+}
+//*****************************************************************************
+//
+void lcd_view_font (uint8_t page)
+{
+        int x;
+        int y;
+        lcd_cls ();
+        lcd_printp (PSTR("  0123456789ABCDEF\r\n"), 0);
+//      lcd_printpns_at (0, 7, PSTR(" \x16    \x17     Exit"), 0);
+        lcd_printpns_at (0, 7, PSTR(" \x1a    \x1b     Exit"), 0);
+        lcd_ypos = 2;
+        for (y = page * 4 ; y < (page * 4 + 4); y++)
+        {
+                if (y < 10)
+                {
+                        lcd_putc (0, lcd_ypos, '0' + y, 0);
+                }
+                else
+                {
+                        lcd_putc (0, lcd_ypos, 'A' + y - 10, 0);
+                }
+                lcd_xpos = 2;
+                for (x = 0; x < 16; x++)
+                {
+                        lcd_putc (lcd_xpos, lcd_ypos, y * 16 + x, 0);
+                        lcd_xpos++;
+                }
+                lcd_ypos++;
+        }
+}
+uint8_t hdigit (uint8_t d)
+{
+        if (d < 10)
+        {
+                return '0' + d;
+        }
+        else
+        {
+                return 'A' + d - 10;
+        }
+}
+void lcd_print_hex_at (uint8_t x, uint8_t y, uint8_t h, uint8_t mode)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_putc (lcd_xpos++, lcd_ypos, hdigit (h >> 4), mode);
+        lcd_putc (lcd_xpos, lcd_ypos, hdigit (h & 0x0f), mode);
+}
+void lcd_write_number_u (uint8_t number)
+{
+        uint8_t num = 100;
+        uint8_t started = 0;
+        while (num > 0)
+        {
+                uint8_t b = number / num;
+                if (b > 0 || started || num == 1)
+                {
+                        lcd_putc (lcd_xpos++, lcd_ypos, '0' + b, 0);
+                        started = 1;
+                }
+                number -= b * num;
+                num /= 10;
+        }
+}
+void lcd_write_number_u_at (uint8_t x, uint8_t y, uint8_t number)
+{
+        lcd_xpos = x;
+        lcd_ypos = y;
+        lcd_write_number_u (number);
+}
+/**
+ * Write only some digits of a unsigned <number> at <x>/<y> to MAX7456 display memory
+ * <num> represents the largest multiple of 10 that will still be displayable as
+ * the first digit, so num = 10 will be 0-99 and so on
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_u (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
+{
+        char s[7];
+        utoa(number, s, 10 );
+        uint8_t len = strlen(s);
+        if (length < len)
+        {
+                for (uint8_t i = 0; i < length; i++)
+                {
+                        lcd_putc (x++, y, '*', 0);
+                }
+                return;
+        }
+        for (uint8_t i = 0; i < length - len; i++)
+        {
+                if (pad)
+                {
+                        lcd_putc (x++, y, '0', 0);
+                }
+                else
+                {
+                        lcd_putc (x++, y, ' ', 0);
+                }
+        }
+        lcd_print_at(x, y, s, 0);
+}
+/**
+ * Write only some digits of a signed <number> at <x>/<y> to MAX7456 display memory
+ * <num> represents the largest multiple of 10 that will still be displayable as
+ * the first digit, so num = 10 will be 0-99 and so on
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_s (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad)
+{
+        char s[7];
+        itoa(number, s, 10 );
+        uint8_t len = strlen(s);
+        if (length < len)
+        {
+                for (uint8_t i = 0; i < length; i++)
+                {
+                        lcd_putc (x++, y, '*', 0);
+                }
+                return;
+        }
+        for (uint8_t i = 0; i < length - len; i++)
+        {
+                if (pad)
+                {
+                        lcd_putc (x++, y, '0', 0);
+                }
+                else
+                {
+                        lcd_putc (x++, y, ' ', 0);
+                }
+        }
+        lcd_print_at(x, y, s, 0);
+}
+/**
+ * Write only some digits of a unsigned <number> at <x>/<y> to MAX7456 display memory
+ * as /10th of the value
+ * <num> represents the largest multiple of 10 that will still be displayable as
+ * the first digit, so num = 10 will be 0-99 and so on
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_u_10th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
+{
+        char s[7];
+        itoa(number, s, 10 );
+        uint8_t len = strlen(s);
+        if (length < len)
+        {
+                for (uint8_t i = 0; i < length; i++)
+                {
+                        lcd_putc (x++, y, '*', 0);
+                }
+                return;
+        }
+        for (uint8_t i = 0; i < length - len; i++)
+        {
+                if (pad)
+                {
+                        lcd_putc (x++, y, '0', 0);
+                }
+                else
+                {
+                        lcd_putc (x++, y, ' ', 0);
+                }
+        }
+        char rest = s[len - 1];
+        s[len - 1] = 0;
+        if (len == 1)
+        {
+                lcd_putc (x-1, y, '0', 0);
+        }
+        else if (len == 2 && s[0] == '-')
+        {
+                lcd_putc (x-1, y, '-', 0);
+                lcd_putc (x, y, '0', 0);
+        }
+        else
+        {
+                lcd_print_at(x, y, s, 0);
+        }
+        x += len - 1;
+        lcd_putc (x++, y, '.', 0);
+        lcd_putc (x++, y, rest, 0);
+}
+void write_ndigit_number_u_100th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad)
+{
+        uint8_t num = 100;
+        while (num > 0)
+        {
+                uint8_t b = number / num;
+                if ((num / 10) == 1)
+                {
+                        lcd_putc (x++, y, '.', 0);
+                }
+                lcd_putc (x++, y, '0' + b, 0);
+                number -= b * num;
+                num /= 10;
+        }
+}
+/**
+ * Write only some digits of a signed <number> at <x>/<y> to MAX7456 display memory
+ * as /10th of the value
+ * <num> represents the largest multiple of 10 that will still be displayable as
+ * the first digit, so num = 10 will be 0-99 and so on
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_s_10th (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad)
+{
+        char s[7];
+        itoa (number, s, 10 );
+        uint8_t len = strlen(s);
+        if (length < len)
+        {
+                for (uint8_t i = 0; i < length; i++)
+                {
+                        lcd_putc (x++, y, '*', 0);
+                }
+                return;
+        }
+        for (uint8_t i = 0; i < length - len; i++)
+        {
+                if (pad)
+                {
+                        lcd_putc (x++, y, '0', 0);
+                }
+                else
+                {
+                        lcd_putc (x++, y, ' ', 0);
+                }
+        }
+        char rest = s[len - 1];
+        s[len - 1] = 0;
+        if (len == 1)
+        {
+                lcd_putc (x-1, y, '0', 0);
+        }
+        else if (len == 2 && s[0] == '-')
+        {
+                lcd_putc (x-1, y, '-', 0);
+                lcd_putc (x, y, '0', 0);
+        }
+        else
+        {
+                lcd_print_at(x, y, s, 0);
+        }
+        x += len - 1;
+        lcd_putc (x++, y, '.', 0);
+        lcd_putc (x++, y, rest, 0);
+}
+/**
+ *  write <seconds> as human readable time at <x>/<y> to MAX7456 display mem
+ */
+void write_time (uint8_t x, uint8_t y, uint16_t seconds)
+{
+        uint16_t min = seconds / 60;
+        seconds -= min * 60;
+        write_ndigit_number_u (x, y, min, 2, 0);
+        lcd_putc (x + 2, y, ':', 0);
+        write_ndigit_number_u (x + 3, y, seconds, 2, 1);
+}
+/**
+ * wirte a <position> at <x>/<y> assuming it is a gps position for long-/latitude
+ */
+void write_gps_pos (uint8_t x, uint8_t y, int32_t position)
+{
+        if (position < 0)
+        {
+                position ^= ~0;
+                position++;
+                lcd_putc (x++, y, '-', 0);
+        }
+        else
+        {
+                lcd_putc (x++, y, ' ', 0);
+        }
+        write_ndigit_number_u (x, y, (uint16_t) (position / (int32_t) 10000000), 3, 1);
+        lcd_putc (x + 3, y, '.', 0);
+        position = position - ((position / (int32_t) 10000000) * (int32_t) 10000000);
+        write_ndigit_number_u (x + 4, y, (uint16_t) (position / (int32_t) 1000), 4, 1);
+        position = position - ((uint16_t) (position / (int32_t) 1000) * (int32_t) 1000);
+        write_ndigit_number_u (x + 8, y, (uint16_t) position, 3, 1);
+        lcd_putc (x + 11, y, 0x1e, 0);  // degree symbol
+}

 /Transportables_Koptertool/trunk/lcd.h
 ,0 → 1,122
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   - original LCD control by Thomas "thkais" Kaiser                        *
+ *   - special number formating routines taken from C-OSD                    *
+ *      from Claas Anders "CaScAdE" Rathje                                   *
+ *   - some extension, ellipse and circ_line by Peter "woggle" Mack          *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _LCD_H
+#define _LCD_H
+//*****************************************************************************
+//
+extern volatile uint8_t LCD_ORIENTATION;
+extern uint8_t lcd_xpos;
+extern uint8_t lcd_ypos;
+//*****************************************************************************
+//
+void LCD_Init (void);
+void lcd_putc (uint8_t x, uint8_t y, uint8_t c, uint8_t mode);
+//void send_byte (uint8_t data);
+void lcd_print (uint8_t *text, uint8_t mode);
+void lcd_print_at (uint8_t x, uint8_t y, uint8_t *text, uint8_t mode);
+void lcd_printp (const char *text, uint8_t mode);
+void lcd_printp_at (uint8_t x, uint8_t y, const char *text, uint8_t mode);
+void lcd_printpns (const char *text, uint8_t mode);
+void lcd_printpns_at (uint8_t x, uint8_t y, const char *text, uint8_t mode);
+void lcd_cls (void);
+void print_display (uint8_t *text);
+void print_display_at (uint8_t x, uint8_t y, uint8_t *text);
+// Jeti
+void lcd_putc_jeti (uint8_t x, uint8_t y, uint8_t c, uint8_t mode);
+void lcd_printpj (const char *text, uint8_t mode);
+void lcd_printpj_at (uint8_t x, uint8_t y, const char *text, uint8_t mode);
+void lcd_plot (uint8_t x, uint8_t y, uint8_t mode);
+void lcd_line (unsigned char x1, unsigned char y1, unsigned char x2, unsigned char y2, uint8_t mode);
+void lcd_rect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode);
+void lcd_frect (uint8_t x1, uint8_t y1, uint8_t widthx, uint8_t widthy, uint8_t mode);
+void lcd_circle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode);
+void lcd_fcircle (int16_t x0, int16_t y0, int16_t radius);
+void lcd_circ_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode);
+void lcd_ellipse (int16_t x0, int16_t y0, int16_t rx, int16_t ry, uint8_t mode);
+void lcd_ellipse_line (uint8_t x, uint8_t y, uint8_t rx, uint8_t ry, uint16_t deg, uint8_t mode);
+void lcd_ecircle (int16_t x0, int16_t y0, int16_t radius, uint8_t mode);
+void lcd_ecirc_line (uint8_t x, uint8_t y, uint8_t r, uint16_t deg, uint8_t mode);
+void lcd_view_font (uint8_t page);
+void lcd_print_hex_at (uint8_t x, uint8_t y, uint8_t h, uint8_t mode);
+void lcd_write_number_u (uint8_t number);
+void lcd_write_number_u_at (uint8_t x, uint8_t y, uint8_t number);
+/**
+ * Write only some digits of a unsigned <number> at <x>/<y>
+ * <length> represents the length to rightbound the number
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_u (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad);
+/**
+ * Write only some digits of a signed <number> at <x>/<y>
+ * <length> represents the length to rightbound the number
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 007 instead of   7
+ */
+void write_ndigit_number_s (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad);
+/**
+ * Write only some digits of a unsigned <number> at <x>/<y> as /10th of the value
+ * <length> represents the length to rightbound the number
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 00.7 instead of   .7
+ */
+void write_ndigit_number_u_10th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad);
+/**
+ * Write only some digits of a unsigned <number> at <x>/<y> as /100th of the value
+ * <length> represents the length to rightbound the number
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 00.7 instead of   .7
+ */
+void write_ndigit_number_u_100th (uint8_t x, uint8_t y, uint16_t number, int16_t length, uint8_t pad);
+/**
+ * Write only some digits of a signed <number> at <x>/<y> as /10th of the value
+ * <length> represents the length to rightbound the number
+ * <pad> = 1 will cause blank spaced to be filled up with zeros e.g. 00.7 instead of   .7
+ */
+void write_ndigit_number_s_10th (uint8_t x, uint8_t y, int16_t number, int16_t length, uint8_t pad);
+/**
+ *  write <seconds> as human readable time at <x>/<y>
+ */
+void write_time (uint8_t x, uint8_t y, uint16_t seconds);
+/**
+ * wirte a <position> at <x>/<y> assuming it is a gps position for long-/latitude
+ */
+void write_gps_pos (uint8_t x, uint8_t y, int32_t position);
+#endif

 /Transportables_Koptertool/trunk/lipo.c
 ,0 → 1,105
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include "main.h"               // LEDs
+#include "timer.h"      // Keys
+#include "lcd.h"
+#include "lipo.h"
+volatile uint8_t AD_Ready = 0;
+volatile uint8_t AD_Channel = 0;
+volatile uint16_t AD_Val[4];
+volatile uint8_t AD_WarnLevel;
+volatile uint8_t AD_Warn = 0;
+//*****************************************************************************
+//
+ISR(ADC_vect)
+{
+        //      LED1_TOGGLE;
+        AD_Val[AD_Channel] = ADC;
+        if (AD_Val[AD_Channel] <= (AD_WarnLevel * 20))
+        {
+                AD_Warn |= (1 << AD_Channel);
+        }
+        AD_Channel++;
+        AD_Channel &= 0x03;
+        ADMUX = (ADMUX & 0xe0) | AD_Channel;
+        if (AD_Channel)
+        {
+                ADCSRA |= (1 << ADSC);
+        }
+        else
+        {
+                AD_Ready = 1;
+        }
+}
+//*****************************************************************************
+//
+void ADC_Init(void)
+{
+        DIDR0 = 0x0f; // disable digital inputs on PA0-3
+        ADMUX = (1 << REFS1) | (1 << REFS0);    // internal 2.56 V ref.
+        ADCSRB = 0;     // free running mode
+        // enable ADC, start conversion, auto trigger, enable interrupt, prescaler = 128
+        ADCSRA = (1 << ADEN) | (1 << ADSC) | (0 << ADATE) | (1 << ADIE) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);
+}
+//*****************************************************************************
+//
+void lipo (void)
+{
+        uint8_t i;
+        lcd_cls ();
+        lcd_printp_at (0, 0, PSTR("LiPo Display"), 0);
+        lcd_printpns_at (0, 7, PSTR("            Exit"), 0);
+        lcd_printp_at (0, 2, PSTR("Cell 1:"), 0);
+        lcd_printp_at (0, 3, PSTR("Cell 2:"), 0);
+        lcd_printp_at (0, 4, PSTR("Cell 3:"), 0);
+        lcd_printp_at (0, 5, PSTR("Cell 4:"), 0);
+        do
+        {
+                if (AD_Ready)
+                {
+                        for (i = 0; i < 4; i++)
+                        {
+                                //write_ndigit_number_u (0, 2 + i, AD_Val[i], 4, 0);
+                                //write_ndigit_number_u_10th (6, 2 + i, AD_Val[i] >> 1, 3, 0);
+                                write_ndigit_number_u_100th (10, 2 + i, AD_Val[i] >> 1, 10, 0);
+                        }
+                        AD_Ready = 0;
+                        ADCSRA |= (1 << ADSC);
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        get_key_press(KEY_ALL);
+}

 /Transportables_Koptertool/trunk/lipo.h
 ,0 → 1,34
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _LIPO_H
+#define _LIPO_H
+//*****************************************************************************
+//
+extern volatile uint16_t AD_Val[4];
+extern volatile uint8_t AD_WarnLevel;
+extern volatile uint8_t AD_Warn;
+//*****************************************************************************
+//
+void ADC_Init(void);
+void lipo (void);
+#endif

 /Transportables_Koptertool/trunk/main.c
 ,0 → 1,172
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *                                                                           *
+ *   Credits to:                                                             *
+ *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN  *
+ *                          http://www.mikrokopter.de                        *
+ *   Gregor "killagreg" Stobrawa for his version of the MK code              *
+ *   Thomas Kaiser "thkais" for the original project. See                    *
+ *                          http://www.ft-fanpage.de/mikrokopter/            *
+ *                          http://forum.mikrokopter.de/topic-4061-1.html    *
+ *   Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
+ *                          http://www.mylifesucks.de/oss/c-osd/             *
+ *****************************************************************************/
+#include <inttypes.h>
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <avr/eeprom.h>
+#include <util/delay.h>
+#include "main.h"
+#include "lcd.h"
+#include "usart.h"
+#include "parameter.h"
+#include "menu.h"
+#include "display.h"
+#include "timer.h"
+#include "jeti.h"
+#include "lipo.h"
+#include "eeprom.h"
+#include "mk-data-structs.h"
+#ifndef USE_MMT
+#define LEDS    // my development board has some status LEDs
+#endif
+//#define MTEST // Menu Test (skip FC/NC detection)
+Version_t *version;
+volatile uint8_t mode = 0;
+uint8_t hardware = 0;
+uint8_t current_hardware = 0;
+int main (void)
+{
+        uint8_t timeout;
+        PORTA = 0xF0;
+        PORTB = 0x43;
+#if defined (__AVR_ATmega32__)
+        PORTC = 0xFC;
+#else
+        PORTC = 0xFF;
+#endif
+        PORTD = 0x70;
+#ifdef LEDS
+        DDRC = 0x1C;
+        DDRD = 0xF0;
+#else
+#if defined (__AVR_ATmega32__)
+        DDRC = 0x03;
+#endif
+        DDRD = 0x80;
+#endif
+        ReadParameter ();
+        LCD_Init ();
+        USART_Init ();
+        TIMER0_Init ();
+#ifndef USE_MMT
+        JETI_Init();
+        ADC_Init();
+#endif
+        sei ();
+#ifndef MTEST
+        lcd_cls ();
+#ifdef USE_MMT
+        lcd_printp (PSTR("Portable Kopter Tool\r\n"), 0);
+#else
+        lcd_printp (PSTR("MK Multi Box\r\n"), 0);
+#endif
+        lcd_printp (PSTR("checking hardware..."), 0);
+        // switch to NC
+        USART_putc (0x1b);
+        USART_putc (0x1b);
+        USART_putc (0x55);
+        USART_putc (0xaa);
+        USART_putc (0x00);
+        mode = 'V';
+        timeout = 50;
+        while (!rxd_buffer_locked && timeout)
+        {
+                SendOutData('v', ADDRESS_ANY, 0);
+                timer = 20;
+                while (timer > 0);
+                timeout--;
+        }
+        if (timeout != 0)
+        {
+                Decode64 ();
+                version = (Version_t *) pRxData;
+                lcd_cls ();
+#ifdef USE_MMT
+                lcd_printp (PSTR("Portable Kopter Tool\r\n"), 0);
+#else
+                lcd_printp (PSTR("MK Multi Box\r\n"), 0);
+#endif
+                lcd_printp (PSTR("found:\r\n\n"), 0);
+                if ((rxd_buffer[1] - 'a') == ADDRESS_FC)
+                {
+                        lcd_printp (PSTR("Flight-Ctrl\r\n"), 0);
+                        hardware = FC;
+                        current_hardware = hardware;
+                }
+                else if ((rxd_buffer[1] - 'a') == ADDRESS_NC)
+                {
+                        lcd_printp (PSTR("Navi-Ctrl\r\n"), 0);
+                        hardware = NC;
+                        current_hardware = hardware;
+                }
+                lcd_printp (PSTR("Version: "), 0);
+                lcd_write_number_u (version->SWMajor);
+                lcd_printp (PSTR("."), 0);
+                lcd_write_number_u (version->SWMinor);
+                lcd_putc (lcd_xpos, lcd_ypos, version->SWPatch + 'a', 0);
+        }
+        else
+        {       // timeout occured
+                lcd_printp (PSTR("\r\n\nERROR: no data"), 0);
+        }
+        mode = 0;
+        rxd_buffer_locked = FALSE;
+        timer = 200;
+        while (timer > 0);
+#endif
+        for (;;)
+        {
+                main_menu ();
+        }
+}

 /Transportables_Koptertool/trunk/main.h
 ,0 → 1,84
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *                                                                           *
+ *   Credits to:                                                             *
+ *   Holger Buss & Ingo Busker from mikrokopter.de for the MK project + SVN  *
+ *                          http://www.mikrokopter.de                        *
+ *   Gregor "killagreg" Stobrawa for his version of the MK code              *
+ *   Thomas Kaiser "thkais" for the original project. See                    *
+ *                          http://www.ft-fanpage.de/mikrokopter/            *
+ *                          http://forum.mikrokopter.de/topic-4061-1.html    *
+ *   Claas Anders "CaScAdE" Rathje for providing the font and his C-OSD code *
+ *                          http://www.mylifesucks.de/oss/c-osd/             *
+ *****************************************************************************/
+#ifndef _MAIN_H
+#define _MAIN_H
+//*****************************************************************************
+//
+#define set_cs()    (PORTB |=  (1 << PB4))
+#define clr_cs()    (PORTB &= ~(1 << PB4))
+#define set_reset() (PORTB |=  (1 << PB2))
+#define clr_reset() (PORTB &= ~(1 << PB2))
+#define set_A0()    (PORTB |=  (1 << PB3))                      // Data
+#define clr_A0()    (PORTB &= ~(1 << PB3))                      // Command
+#define set_scl()   (PORTB |=  (1 << PB7))
+#define clr_scl()   (PORTB &= ~(1 << PB7))
+#define set_si()    (PORTB |=  (1 << PB5))
+#define clr_si()    (PORTB &= ~(1 << PB5))
+#define LED1_OFF                        PORTC |=  (1 << PC3)
+#define LED1_ON                         PORTC &= ~(1 << PC3)
+#define LED1_TOGGLE             PORTC ^=  (1 << PC3)
+#define LED2_OFF                        PORTD |=  (1 << PD4)
+#define LED2_ON                         PORTD &= ~(1 << PD4)
+#define LED2_TOGGLE             PORTD ^=  (1 << PD4)
+#define LED3_OFF                        PORTD |=  (1 << PD5)
+#define LED3_ON                         PORTD &= ~(1 << PD5)
+#define LED3_TOGGLE             PORTD ^=  (1 << PD5)
+#define LED4_OFF                        PORTD |=  (1 << PD6)
+#define LED4_ON                         PORTD &= ~(1 << PD6)
+#define LED4_TOGGLE             PORTD ^=  (1 << PD6)
+#define LED5_OFF                        PORTC |=  (1 << PC4)
+#define LED5_ON                         PORTC &= ~(1 << PC4)
+#define LED5_TOGGLE             PORTC ^=  (1 << PC4)
+#define LED6_OFF                        PORTC |=  (1 << PC2)
+#define LED6_ON                         PORTC &= ~(1 << PC2)
+#define LED6_TOGGLE             PORTC ^=  (1 << PC2)
+#define LED_ALL_OFF             {LED1_OFF; LED2_OFF; LED3_OFF; LED4_OFF; LED5_OFF; LED6_OFF;}
+#define NC 1
+#define FC 2
+#define MK3MAG 3
+#define MKGPS 4
+//*****************************************************************************
+//
+extern volatile uint8_t mode;
+extern uint8_t hardware;
+extern uint8_t current_hardware;
+#endif

 /Transportables_Koptertool/trunk/menu.c
 ,0 → 1,265
+/*****************************************************************************
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <avr/pgmspace.h>
+#include "main.h"
+#include "lcd.h"
+#include "parameter.h"
+#include "menu.h"
+#include "display.h"
+#include "motortest.h"
+#include "debug.h"
+#include "settings.h"
+#include "timer.h"
+#include "osd.h"
+#include "jeti.h"
+#include "servo.h"
+#include "lipo.h"
+#include "status.h"
+void utils (void);
+void sett (void);
+//*****************************************************************************
+// Main Menu
+const char mm_item_0[] PROGMEM = "Navi Data";
+const char mm_item_1[] PROGMEM = "Display";
+const char mm_item_2[] PROGMEM = "Parameters";
+const char mm_item_3[] PROGMEM = "Debug Data";
+#ifndef USE_MMT
+const char mm_item_4[] PROGMEM = "Jeti";
+#endif
+const char mm_item_5[] PROGMEM = "Utilities...";
+const struct menu menu_main[] PROGMEM = {
+        {mm_item_0, osd},
+        {mm_item_1, display_data},
+        {mm_item_2, edit_parameter},
+        {mm_item_3, display_debug},
+#ifndef USE_MMT
+        {mm_item_4, jeti},
+#endif
+        {mm_item_5, utils},     // sub menu
+};
+#define N_MAIN (sizeof menu_main / sizeof menu_main[0])
+//*****************************************************************************
+// Utilities Menu
+const char mu_item_0[] PROGMEM = "Motor Test";
+const char mu_item_1[] PROGMEM = "I2C Motor Test";
+#ifndef USE_MMT
+const char mu_item_2[] PROGMEM = "Servo Tester";
+const char mu_item_3[] PROGMEM = "LiPo Status";
+#endif
+const char mu_item_4[] PROGMEM = "Status";
+const char mu_item_5[] PROGMEM = "Settings...";
+const struct menu menu_util[] PROGMEM = {
+        {mu_item_0, motor_test},
+        {mu_item_1, motor_i2c},
+#ifndef USE_MMT
+        {mu_item_2, servo_test},
+        {mu_item_3, lipo},
+#endif
+        {mu_item_4, status},
+        {mu_item_5, sett},      // sub menu
+};
+#define N_UTIL (sizeof menu_util / sizeof menu_util[0])
+//*****************************************************************************
+// Settings Menu
+const char ms_item_0[] PROGMEM = "Orientation";
+#ifndef USE_MMT
+const char ms_item_1[] PROGMEM = "LiPo Warn";
+#endif
+const char ms_item_2[] PROGMEM = "View Font";
+const char ms_item_3[] PROGMEM = "Line";
+const char ms_item_4[] PROGMEM = "Rectangle";
+const struct menu menu_set[] PROGMEM = {
+        {ms_item_0, set_toggledisplay},
+#ifndef USE_MMT
+        {ms_item_1, set_lipo},
+#endif
+        {ms_item_2, set_viewfont},
+        {ms_item_3, set_line},
+        {ms_item_4, set_rect},
+};
+#define N_SET (sizeof menu_set / sizeof menu_set[0])
+#if 0
+const struct menus PROGMEM = {
+        {menu_main, N_MAIN, title_main},
+        {menu_util, N_UTIL, title_util},
+        {menu_set,  N_SET,  title_set},
+};
+#endif
+//*****************************************************************************
+//
+void menu_print (const struct menu m[], uint8_t size)
+{
+        uint8_t i;
+        for (i = MENU_LINE; i < MENU_LINE + size; i++)
+        {
+                lcd_printp_at (MENU_COL, i, (const char *) pgm_read_word(&(m[i - MENU_LINE].str)), 0);
+        }
+        lcd_printpns_at (0, 7, PSTR(" \x1a    \x1b     Back   \x0c"), 0);
+}
+//*****************************************************************************
+//
+void utils (void)
+{
+        static uint8_t f = MENU_LINE;
+        do
+        {
+                lcd_cls ();
+                lcd_printp (PSTR("Utilities:"), 0);
+                menu_print(menu_util, N_UTIL);
+                f = menu_choose (MENU_LINE, N_UTIL, CURSOR_COL, f);
+                if (f != 255)
+                {
+                        ((pfunc)(pgm_read_word (&(menu_util[f - MENU_LINE].func))))();
+                }
+        }
+        while (f != 255);
+        f = MENU_LINE;
+}
+//*****************************************************************************
+//
+void sett (void)
+{
+        static uint8_t f = MENU_LINE;
+        do
+        {
+                lcd_cls ();
+                lcd_printp (PSTR("Settings:"), 0);
+                menu_print(menu_set, N_SET);
+                f = menu_choose (MENU_LINE, N_SET, CURSOR_COL, f);
+                if (f != 255)
+                {
+                        ((pfunc)(pgm_read_word (&(menu_set[f - MENU_LINE].func))))();
+                }
+        }
+        while (f != 255);
+        f = MENU_LINE;
+}
+//*****************************************************************************
+// print cursor
+void menu_set_cursor (uint8_t before, uint8_t line, uint8_t pos)
+{
+        lcd_printp_at (pos, before, PSTR(" "), 0);
+        lcd_printp_at (pos, line, PSTR("\x1D"), 0);
+}
+//*****************************************************************************
+//
+uint8_t menu_choose (uint8_t min, uint8_t max, uint8_t pos, uint8_t start)
+{
+        uint8_t line = start;
+        uint8_t before = start;
+        uint8_t k;
+        menu_set_cursor (line, line, pos);
+        do
+        {
+                if (get_key_press (1 << KEY_PLUS))
+                {
+                        if (line < max)
+                        {
+                                line ++;
+                        }
+                        else
+                        {
+                                line = min;
+                        }
+                }
+                if (get_key_press (1 << KEY_MINUS))
+                {
+                        if (line > min)
+                        {
+                                line --;
+                        }
+                        else
+                        {
+                                line = max;
+                        }
+                }
+                if (line != before)
+                {
+                        menu_set_cursor (before, line, pos);
+                        before = line;
+                }
+        }
+        while (!(k = get_key_press ((1 << KEY_ENTER) | (1 << KEY_ESC))));
+        if (k & (1 << KEY_ESC))
+        {
+                line = 255;
+        }
+        return line;
+}
+//*****************************************************************************
+//
+void main_menu (void)
+{
+        static uint8_t f = MENU_LINE;
+        lcd_cls ();
+        //lcd_printp (PSTR("Portable Kopter Tool"), 0);
+        lcd_printp (PSTR("MK Multi Box"), 0);
+        menu_print(menu_main, N_MAIN);
+        f = menu_choose (MENU_LINE, N_MAIN, CURSOR_COL, f);
+        if (f != 255)
+        {
+                ((pfunc)(pgm_read_word (&(menu_main[f - MENU_LINE].func))))();
+        }
+        else
+        {
+                f = MENU_LINE;
+        }
+}

 /Transportables_Koptertool/trunk/menu.h
 ,0 → 1,43
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _MENU_H
+#define _MENU_H
+//*****************************************************************************
+//
+#define CURSOR_COL      1       // column where the menu cursor is displayed
+#define MENU_LINE 1             // starting line of menu
+#define MENU_COL 3              // column where the menu starts
+//*****************************************************************************
+//
+typedef void(*pfunc)(void);
+struct menu {
+        const char *str;
+        pfunc func;
+};
+//*****************************************************************************
+//
+void main_menu (void);
+uint8_t menu_choose (uint8_t min, uint8_t max, uint8_t pos, uint8_t start);
+#endif

 /Transportables_Koptertool/trunk/mk-data-structs.h
 ,0 → 1,390
+/****************************************************************************
+ *   Copyright (C) 2009 by Claas Anders "CaScAdE" Rathje                    *
+ *   admiralcascade@gmail.com                                               *
+ *   Project-URL: http://www.mylifesucks.de/oss/c-osd/                      *
+ *                                                                          *
+ *   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 2 of the License.         *
+ *                                                                          *
+ *   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, write to the                          *
+ *   Free Software Foundation, Inc.,                                        *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.              *
+ ****************************************************************************/
+/* ##########################################################################
+ * gain some fake arm compat :)
+ * ##########################################################################*/
+#define u8 uint8_t
+#define s8 int8_t
+#define u16 uint16_t
+#define s16 int16_t
+#define u32 uint32_t
+#define s32 int32_t
+//*****************************************************************************
+//
+#define NUMBER_OF_DEBUG_DATAS 32
+#define ANALOG_NAME_LENGTH 16
+// Version of supported serial protocol
+#define MIN_VERSION 7
+#define MAX_VERSION 10
+// Setting index
+#define SETTING_1       1
+#define SETTING_2       2
+#define SETTING_3       3
+#define SETTING_4       4
+#define SETTING_5       5
+#define SETTING_CURRENT 0xff
+typedef struct
+{
+        unsigned char SWMajor;
+        unsigned char SWMinor;
+        unsigned char ProtoMajor;
+        unsigned char ProtoMinor;
+        unsigned char SWPatch;
+        unsigned char Reserved[5];
+} __attribute__((packed)) Version_t;
+/*
+ * FC Debug Struct
+ * portions taken and adapted from
+ * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.72p%2Fuart.h
+ */
+typedef struct {
+        uint8_t Digital[2];
+        // NC: unsigned; FC: signed !!!!
+        int16_t Analog[32];     // Debugvalues
+} __attribute__((packed)) DebugData_t;
+typedef struct {
+        uint8_t line;
+        uint8_t text[20];
+} __attribute__((packed)) Display_t;
+typedef struct
+{
+        char Revision;
+        char Name[12];
+        signed char Motor[16][4];
+} __attribute__((packed)) Mixer_t;
+/*
+ * NaviCtrl OSD Structs
+ * portions taken and adapted from
+ * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=NaviCtrl&path=%2Ftags%2FV0.15c%2Fuart1.h
+ */
+typedef struct
+{
+        s16 AngleNick;  // in 0.1 deg
+        s16 AngleRoll;   // in 0.1 deg
+        s16 Heading;    // in 0.1 deg
+        u8 reserve[8];
+} __attribute__((packed)) Data3D_t;
+typedef struct {
+        s32 Longitude;  // in 1E-7 deg
+        s32 Latitude;           // in 1E-7 deg
+        s32 Altitude;           // in mm
+        u8 Status;                      // validity of data
+} __attribute__((packed)) GPS_Pos_t;
+typedef struct {
+        s16 Distance;           // distance to target in cm
+        s16 Bearing;            // course to target in deg
+} __attribute__((packed)) GPS_PosDev_t;
+#if 0
+typedef struct {
+        u8 Version;                                                     // version of the data structure
+        GPS_Pos_t CurrentPosition;      // see ubx.h for details
+        GPS_Pos_t TargetPosition;
+        GPS_PosDev_t TargetPositionDeviation;
+        GPS_Pos_t HomePosition;
+        GPS_PosDev_t HomePositionDeviation;
+        u8  WaypointIndex;                      // index of current waypoints running from 0 to WaypointNumber-1
+        u8  WaypointNumber;                     // number of stored waypoints
+        u8  SatsInUse;                                  // number of satellites used for position solution
+        s16 Altimeter;                                  // hight according to air pressure
+        s16 Variometer;                                 // climb(+) and sink(-) rate
+        u16 FlyingTime;                                 // in seconds
+        u8  UBat;                                                               // Battery Voltage in 0.1 Volts
+        u16 GroundSpeed;                                // speed over ground in cm/s (2D)
+        s16 Heading;                                            // current flight direction in ∞ as angle to north
+        s16     CompassHeading;                 // current compass value in ∞
+        s8  AngleNick;                                  // current Nick angle in 1∞
+        s8  AngleRoll;                                  // current Rick angle in 1∞
+        u8  RC_Quality;                                 // RC_Quality
+        u8  MKFlags;                                            // Flags from FC
+        u8  NCFlags;                                            // Flags from NC
+        u8  Errorcode;                                  // 0 --> okay
+        u8  OperatingRadius;            // current operation radius around the Home Position in m
+        s16 TopSpeed;                                           // velocity in vertical direction in cm/s
+        u8 TargetHoldTime;                      // time in s to stay at the given target, counts down to 0 if target has been reached
+        u8  Reserve[4];                                 // for future use
+} __attribute__((packed)) NaviData_t;
+#endif
+typedef struct
+{
+        u8 Version;                                                     // version of the data structure
+        GPS_Pos_t CurrentPosition;      // see ubx.h for details
+        GPS_Pos_t TargetPosition;
+        GPS_PosDev_t TargetPositionDeviation;
+        GPS_Pos_t HomePosition;
+        GPS_PosDev_t HomePositionDeviation;
+        u8  WaypointIndex;                      // index of current waypoints running from 0 to WaypointNumber-1
+        u8  WaypointNumber;                     // number of stored waypoints
+        u8  SatsInUse;                                  // number of satellites used for position solution
+        s16 Altimeter;                                  // hight according to air pressure
+        s16 Variometer;                                 // climb(+) and sink(-) rate
+        u16 FlyingTime;                                 // in seconds
+        u8  UBat;                                                               // Battery Voltage in 0.1 Volts
+        u16 GroundSpeed;                                // speed over ground in cm/s (2D)
+        s16 Heading;                                            // current flight direction in ° as angle to north
+        s16     CompassHeading;                 // current compass value in °
+        s8  AngleNick;                                  // current Nick angle in 1°
+        s8  AngleRoll;                                  // current Rick angle in 1°
+        u8  RC_Quality;                                 // RC_Quality
+        u8  FCFlags;                                            // Flags from FC
+        u8  NCFlags;                                            // Flags from NC
+        u8  Errorcode;                                  // 0 --> okay
+        u8  OperatingRadius;            // current operation radius around the Home Position in m
+        s16 TopSpeed;                                           // velocity in vertical direction in cm/s
+        u8  TargetHoldTime;                     // time in s to stay at the given target, counts down to 0 if target has been reached
+        u8  RC_RSSI;                                            // Receiver signal strength (since version 2 added)
+        s16 SetpointAltitude;           // setpoint for altitude
+        u8  Gas;                                                                // for future use
+        u16 Current;                                            // actual current in 0.1A steps
+        u16 UsedCapacity;                               // used capacity in mAh
+} __attribute__((packed)) NaviData_t;
+/*
+ * MikroKopter Flags
+ * taken from
+ * http://svn.mikrokopter.de/mikrowebsvn/filedetails.php?repname=FlightCtrl&path=%2Ftags%2FV0.73d%2Ffc.h
+ */
+#define FCFLAG_MOTOR_RUN  0x01
+#define FCFLAG_FLY        0x02
+#define FCFLAG_CALIBRATE  0x04
+#define FCFLAG_START      0x08
+#define FCFLAG_NOTLANDUNG 0x10
+#define FCFLAG_LOWBAT                   0x20
+#define FCFLAG_SPI_RX_ERR       0x40
+#define FCFLAG_I2CERR                   0x80
+/*
+ * NaviCtrl Flags
+ * taken from
+ * http://mikrocontroller.cco-ev.de/mikrowebsvn/filedetails.php?repname=NaviCtrl&path=%2Ftags%2FV0.15c%2Fuart1.h
+ */
+#define NC_FLAG_FREE                                            0x01
+#define NC_FLAG_PH                                                      0x02
+#define NC_FLAG_CH                                                      0x04
+#define NC_FLAG_RANGE_LIMIT                     0x08
+#define NC_FLAG_NOSERIALLINK            0x10
+#define NC_FLAG_TARGET_REACHED  0x20
+#define NC_FLAG_MANUAL_CONTROL  0x40
+#define NC_FLAG_8                                                               0x80
+#if 0
+typedef struct
+{
+        unsigned char Kanalbelegung[8];       // GAS[0], GIER[1],NICK[2], ROLL[3], POTI1, POTI2, POTI3
+        unsigned char GlobalConfig;           // 0x01=Höhenregler aktiv,0x02=Kompass aktiv, 0x04=GPS aktiv, 0x08=Heading Hold aktiv
+        unsigned char Hoehe_MinGas;           // Wert : 0-100
+        unsigned char Luftdruck_D;            // Wert : 0-250
+        unsigned char MaxHoehe;               // Wert : 0-32
+        unsigned char Hoehe_P;                // Wert : 0-32
+        unsigned char Hoehe_Verstaerkung;     // Wert : 0-50
+        unsigned char Hoehe_ACC_Wirkung;      // Wert : 0-250
+        unsigned char Hoehe_HoverBand;        // Wert : 0-250
+        unsigned char Hoehe_GPS_Z;            // Wert : 0-250
+        unsigned char Hoehe_StickNeutralPoint;// Wert : 0-250
+        unsigned char Stick_P;                // Wert : 1-6
+        unsigned char Stick_D;                // Wert : 0-64
+        unsigned char Gier_P;                 // Wert : 1-20
+        unsigned char Gas_Min;                // Wert : 0-32
+        unsigned char Gas_Max;                // Wert : 33-250
+        unsigned char GyroAccFaktor;          // Wert : 1-64
+        unsigned char KompassWirkung;         // Wert : 0-32
+        unsigned char Gyro_P;                 // Wert : 10-250
+        unsigned char Gyro_I;                 // Wert : 0-250
+        unsigned char Gyro_D;                 // Wert : 0-250
+        unsigned char Gyro_Gier_P;            // Wert : 10-250
+        unsigned char Gyro_Gier_I;            // Wert : 0-250
+        unsigned char UnterspannungsWarnung;  // Wert : 0-250
+        unsigned char NotGas;                 // Wert : 0-250     //Gaswert bei Empängsverlust
+        unsigned char NotGasZeit;             // Wert : 0-250     // Zeitbis auf NotGas geschaltet wird, wg. Rx-Problemen
+        unsigned char UfoAusrichtung;         // X oder + Formation
+        unsigned char I_Faktor;               // Wert : 0-250
+        unsigned char UserParam1;             // Wert : 0-250
+        unsigned char UserParam2;             // Wert : 0-250
+        unsigned char UserParam3;             // Wert : 0-250
+        unsigned char UserParam4;             // Wert : 0-250
+        unsigned char ServoNickControl;       // Wert : 0-250     // Stellung des Servos
+        unsigned char ServoNickComp;          // Wert : 0-250     // Einfluss Gyro/Servo
+        unsigned char ServoNickMin;           // Wert : 0-250     // Anschlag
+        unsigned char ServoNickMax;           // Wert : 0-250     // Anschlag
+                                                                                                                                                                //--- Seit V0.75
+        unsigned char ServoRollControl;       // Wert : 0-250     // Stellung des Servos
+        unsigned char ServoRollComp;          // Wert : 0-250
+        unsigned char ServoRollMin;           // Wert : 0-250
+        unsigned char ServoRollMax;           // Wert : 0-250
+                                                                                                                                                                //---
+        unsigned char ServoNickRefresh;       //
+        unsigned char LoopGasLimit;           // Wert: 0-250  max. Gas während Looping
+        unsigned char LoopThreshold;          // Wert: 0-250  Schwelle für Stickausschlag
+        unsigned char LoopHysterese;          // Wert: 0-250  Hysterese für Stickausschlag
+        unsigned char AchsKopplung1;          // Wert: 0-250  Faktor, mit dem Gier die Achsen Roll und Nick koppelt (NickRollMitkopplung)
+        unsigned char AchsKopplung2;          // Wert: 0-250  Faktor, mit dem Nick und Roll verkoppelt werden
+        unsigned char CouplingYawCorrection;  // Wert: 0-250  Faktor, mit dem Nick und Roll verkoppelt werden
+        unsigned char WinkelUmschlagNick;     // Wert: 0-250  180°-Punkt
+        unsigned char WinkelUmschlagRoll;     // Wert: 0-250  180°-Punkt
+        unsigned char GyroAccAbgleich;        // 1/k  (Koppel_ACC_Wirkung)
+        unsigned char Driftkomp;
+        unsigned char DynamicStability;
+        unsigned char UserParam5;             // Wert : 0-250
+        unsigned char UserParam6;             // Wert : 0-250
+        unsigned char UserParam7;             // Wert : 0-250
+        unsigned char UserParam8;             // Wert : 0-250
+                                                                                                                                                                //---Output ---------------------------------------------
+        unsigned char J16Bitmask;             // for the J16 Output
+        unsigned char J16Timing;              // for the J16 Output
+        unsigned char J17Bitmask;             // for the J17 Output
+        unsigned char J17Timing;              // for the J17 Output
+                                                                                                                                                                // seit version V0.75c
+        unsigned char WARN_J16_Bitmask;       // for the J16 Output
+        unsigned char WARN_J17_Bitmask;       // for the J17 Output
+                                                                                                                                                                //---NaviCtrl---------------------------------------------
+        unsigned char NaviGpsModeControl;     // Parameters for the Naviboard
+        unsigned char NaviGpsGain;
+        unsigned char NaviGpsP;
+        unsigned char NaviGpsI;
+        unsigned char NaviGpsD;
+        unsigned char NaviGpsPLimit;
+        unsigned char NaviGpsILimit;
+        unsigned char NaviGpsDLimit;
+        unsigned char NaviGpsACC;
+        unsigned char NaviGpsMinSat;
+        unsigned char NaviStickThreshold;
+        unsigned char NaviWindCorrection;
+        unsigned char NaviSpeedCompensation;
+        unsigned char NaviOperatingRadius;
+        unsigned char NaviAngleLimitation;
+        unsigned char NaviPH_LoginTime;
+        //---Ext.Ctrl---------------------------------------------
+        unsigned char ExternalControl;        // for serial Control
+                                                                                                                                                                //------------------------------------------------
+        unsigned char BitConfig;          // (war Loop-Cfg) Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt
+        unsigned char ServoCompInvert;    // //  0x01 = Nick, 0x02 = Roll   0 oder 1  // WICHTIG!!! am Ende lassen
+        unsigned char ExtraConfig;        // bitcodiert
+        char Name[12];
+} __attribute__((packed)) mk_param_struct_t;
+#endif
+typedef struct
+{
+        unsigned char Kanalbelegung[12];      // GAS[0], GIER[1],NICK[2], ROLL[3], POTI1, POTI2, POTI3
+        unsigned char GlobalConfig;           // 0x01=Höhenregler aktiv,0x02=Kompass aktiv, 0x04=GPS aktiv, 0x08=Heading Hold aktiv
+        unsigned char Hoehe_MinGas;           // Wert : 0-100
+        unsigned char Luftdruck_D;            // Wert : 0-250
+        unsigned char MaxHoehe;               // Wert : 0-32
+        unsigned char Hoehe_P;                // Wert : 0-32
+        unsigned char Hoehe_Verstaerkung;     // Wert : 0-50
+        unsigned char Hoehe_ACC_Wirkung;      // Wert : 0-250
+        unsigned char Hoehe_HoverBand;        // Wert : 0-250
+        unsigned char Hoehe_GPS_Z;            // Wert : 0-250
+        unsigned char Hoehe_StickNeutralPoint;// Wert : 0-250
+        unsigned char Stick_P;                // Wert : 1-6
+        unsigned char Stick_D;                // Wert : 0-64
+        unsigned char Gier_P;                 // Wert : 1-20
+        unsigned char Gas_Min;                // Wert : 0-32
+        unsigned char Gas_Max;                // Wert : 33-250
+        unsigned char GyroAccFaktor;          // Wert : 1-64
+        unsigned char KompassWirkung;         // Wert : 0-32
+        unsigned char Gyro_P;                 // Wert : 10-250
+        unsigned char Gyro_I;                 // Wert : 0-250
+        unsigned char Gyro_D;                 // Wert : 0-250
+        unsigned char Gyro_Gier_P;            // Wert : 10-250
+        unsigned char Gyro_Gier_I;            // Wert : 0-250
+        unsigned char UnterspannungsWarnung;  // Wert : 0-250
+        unsigned char NotGas;                 // Wert : 0-250     //Gaswert bei Empängsverlust
+        unsigned char NotGasZeit;             // Wert : 0-250     // Zeitbis auf NotGas geschaltet wird, wg. Rx-Problemen
+        unsigned char Receiver;                           // 0= Summensignal, 1= Spektrum, 2 =Jeti, 3=ACT DSL, 4=ACT S3D
+        unsigned char I_Faktor;               // Wert : 0-250
+        unsigned char UserParam1;             // Wert : 0-250
+        unsigned char UserParam2;             // Wert : 0-250
+        unsigned char UserParam3;             // Wert : 0-250
+        unsigned char UserParam4;             // Wert : 0-250
+        unsigned char ServoNickControl;       // Wert : 0-250     // Stellung des Servos
+        unsigned char ServoNickComp;          // Wert : 0-250     // Einfluss Gyro/Servo
+        unsigned char ServoNickMin;           // Wert : 0-250     // Anschlag
+        unsigned char ServoNickMax;           // Wert : 0-250     // Anschlag
+                                                                                                                                                                //--- Seit V0.75
+        unsigned char ServoRollControl;       // Wert : 0-250     // Stellung des Servos
+        unsigned char ServoRollComp;          // Wert : 0-250
+        unsigned char ServoRollMin;           // Wert : 0-250
+        unsigned char ServoRollMax;           // Wert : 0-250
+                                                                                                                                                                //---
+        unsigned char ServoNickRefresh;       // Speed of the Servo
+        unsigned char Servo3;                         // Value or mapping of the Servo Output
+        unsigned char Servo4;                               // Value or mapping of the Servo Output
+        unsigned char Servo5;                               // Value or mapping of the Servo Output
+        unsigned char LoopGasLimit;           // Wert: 0-250  max. Gas während Looping
+        unsigned char LoopThreshold;          // Wert: 0-250  Schwelle für Stickausschlag
+        unsigned char LoopHysterese;          // Wert: 0-250  Hysterese für Stickausschlag
+        unsigned char AchsKopplung1;          // Wert: 0-250  Faktor, mit dem Gier die Achsen Roll und Nick koppelt (NickRollMitkopplung)
+        unsigned char AchsKopplung2;          // Wert: 0-250  Faktor, mit dem Nick und Roll verkoppelt werden
+        unsigned char CouplingYawCorrection;  // Wert: 0-250  Faktor, mit dem Nick und Roll verkoppelt werden
+        unsigned char WinkelUmschlagNick;     // Wert: 0-250  180°-Punkt
+        unsigned char WinkelUmschlagRoll;     // Wert: 0-250  180°-Punkt
+        unsigned char GyroAccAbgleich;        // 1/k  (Koppel_ACC_Wirkung)
+        unsigned char Driftkomp;
+        unsigned char DynamicStability;
+        unsigned char UserParam5;             // Wert : 0-250
+        unsigned char UserParam6;             // Wert : 0-250
+        unsigned char UserParam7;             // Wert : 0-250
+        unsigned char UserParam8;             // Wert : 0-250
+                                                                                                                                                                //---Output ---------------------------------------------
+        unsigned char J16Bitmask;             // for the J16 Output
+        unsigned char J16Timing;              // for the J16 Output
+        unsigned char J17Bitmask;             // for the J17 Output
+        unsigned char J17Timing;              // for the J17 Output
+                                                                                                                                                                // seit version V0.75c
+        unsigned char WARN_J16_Bitmask;       // for the J16 Output
+        unsigned char WARN_J17_Bitmask;       // for the J17 Output
+                                                                                                                                                                //---NaviCtrl---------------------------------------------
+        unsigned char NaviGpsModeControl;     // Parameters for the Naviboard
+        unsigned char NaviGpsGain;
+        unsigned char NaviGpsP;
+        unsigned char NaviGpsI;
+        unsigned char NaviGpsD;
+        unsigned char NaviGpsPLimit;
+        unsigned char NaviGpsILimit;
+        unsigned char NaviGpsDLimit;
+        unsigned char NaviGpsACC;
+        unsigned char NaviGpsMinSat;
+        unsigned char NaviStickThreshold;
+        unsigned char NaviWindCorrection;
+        unsigned char NaviSpeedCompensation;
+        unsigned char NaviOperatingRadius;
+        unsigned char NaviAngleLimitation;
+        unsigned char NaviPH_LoginTime;
+        //---Ext.Ctrl---------------------------------------------
+        unsigned char ExternalControl;        // for serial Control
+                                                                                                                                                                //------------------------------------------------
+        unsigned char BitConfig;              // (war Loop-Cfg) Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt
+        unsigned char ServoCompInvert;        // //  0x01 = Nick, 0x02 = Roll   0 oder 1  // WICHTIG!!! am Ende lassen
+        unsigned char ExtraConfig;            // bitcodiert
+        char Name[12];
+} __attribute__((packed)) mk_param_struct_t;
+#define  STRUCT_PARAM_LAENGE  sizeof(mk_param_struct_t)

 /Transportables_Koptertool/trunk/motortest.c
 ,0 → 1,281
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <string.h>
+#include <util/twi.h>
+#include "main.h"
+#include "motortest.h"
+#include "lcd.h"
+#include "usart.h"
+#include "timer.h"
+uint8_t m;
+#define SCL_FREQ  200000L
+#define I2C_STATE_TX_ADDRESS    0
+#define I2C_STATE_TX_DATA                       1
+#define I2C_STATE_TX_STOP                       2
+#define I2C_STATE_RX_ADDRESS    3
+#define I2C_STATE_RX_1BYTE              4
+#define I2C_STATE_RX_2BYTE              5
+volatile uint8_t i2c_state;
+volatile uint8_t motor_addr = 0;
+//*****************************************************************************
+//
+void I2C_Init(void)
+{
+        uint8_t sreg = SREG;
+        cli();
+        DDRC  &= ~(1<<DDC1);    // SDA is input
+        DDRC |= (1<<DDC0);              // SCL is output
+        PORTC |= (1<<PORTC0)|(1<<PORTC1);       // pull up SDA and SCL
+        // prescaler 1 (TWPS1 = 0, TWPS0 = 0)
+        TWSR &= ~((1<<TWPS1)|(1<<TWPS0));
+        TWBR = ((F_CPU/SCL_FREQ)-16)/2;
+        i2c_state = I2C_STATE_TX_ADDRESS;
+        SREG = sreg;
+}
+//*****************************************************************************
+//
+void I2C_Start(uint8_t start_state)
+{
+        i2c_state = start_state;
+        // generate start condition and enable interrupts
+        TWCR = (1<<TWINT) | (1<<TWSTA) | (1<<TWEN) | (1<<TWIE);
+}
+//*****************************************************************************
+//
+void I2C_Stop(uint8_t start_state)
+{
+        i2c_state = start_state;
+        // generate stop condition and disable interrupt
+        TWCR = (1<<TWINT) | (1<<TWSTO) | (1<<TWEN);
+}
+//*****************************************************************************
+//
+void I2C_WriteByte(int8_t b)
+{
+        TWDR = b;
+        // clear interrupt flag (TWINT = 1)
+        // enable i2c bus (TWEN = 1)
+        // enable interrupt (TWIE = 1)
+        TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
+}
+//*****************************************************************************
+//
+void I2C_ReceiveByte(void)
+{
+        TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE) | (1<<TWEA);
+}
+//*****************************************************************************
+//
+void I2C_ReceiveLastByte(void)
+{
+        TWCR = (1<<TWINT) | (1<<TWEN) | (1<<TWIE);
+}
+//*****************************************************************************
+//
+ISR (TWI_vect)
+{
+        int8_t mrCurrent;
+        int8_t mrMaxpwm;
+        switch (i2c_state++)
+        {
+                // TWI Master Transmit
+                case I2C_STATE_TX_ADDRESS:
+                        I2C_WriteByte(0x52 + (motor_addr * 2) ); // select slave adress in tx mode
+                        break;
+                case I2C_STATE_TX_DATA:
+                        I2C_WriteByte(m);
+                        break;
+                case I2C_STATE_TX_STOP:
+                        if(TWSR == TW_MT_DATA_NACK) // Data transmitted, NACK received
+                        {
+                                // error occured
+                        }
+                        I2C_Stop(I2C_STATE_TX_ADDRESS);
+                        I2C_Start(I2C_STATE_RX_ADDRESS); // Repeated start -> switch slave or switch Master Transmit -> Master Receive
+                        break;
+                        // Master Receive Data
+                case I2C_STATE_RX_ADDRESS:
+                        I2C_WriteByte(0x53 + (motor_addr * 2) ); // select slave adress in rx mode
+                        if(TWSR != TW_MR_SLA_ACK) //  SLA+R transmitted, if not ACK received
+                        {       // no response from the addressed slave received
+                                I2C_Stop(I2C_STATE_TX_ADDRESS);
+                        }
+                        else
+                        {
+                                I2C_ReceiveByte(); //Transmit 1st byte
+                        }
+                        break;
+                case I2C_STATE_RX_1BYTE: //Read 1st byte and transmit 2nd Byte
+                        mrCurrent = TWDR;
+                        I2C_ReceiveLastByte(); // nack
+                        break;
+                case I2C_STATE_RX_2BYTE:
+                        //Read 2nd byte
+                        mrMaxpwm = TWDR;;
+                        I2C_Stop(I2C_STATE_TX_ADDRESS);
+                        break;
+                default:
+                        I2C_Stop(I2C_STATE_TX_ADDRESS);
+                        break;
+        }
+}
+//*****************************************************************************
+//
+void motor_i2c (void)
+{
+        uint8_t blc = 0;
+        lcd_cls ();
+        m = 0;
+        lcd_printp (PSTR("I2C Motor Test"), 0);
+        lcd_printpns_at (0, 7, PSTR("dec  inc    Exit Off"), 0);
+        lcd_printp (PSTR("BLC #"), 0);
+        do
+        {
+                if ((get_key_press (1 << KEY_PLUS) || get_key_rpt (1 << KEY_PLUS)) && (m < 254))
+                {
+                        m++;
+                }
+                if ((get_key_press (1 << KEY_MINUS) || get_key_rpt (1 << KEY_MINUS)) && (m > 0))
+                {
+                        lcd_frect (GX, GY, (m * 108) / 255, 10, 0);
+                        m--;
+                }
+                if (get_key_press (1 << KEY_ENTER))
+                {
+                        lcd_frect (GX, GY, (m * 108) / 255, 10, 0);
+                        m = 0;
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        // switch all engines off at exit !
+}
+//*****************************************************************************
+//
+void motor (uint8_t m)
+{
+        memset (buffer, m, 16);
+#if 0
+        buffer[0] = m;  // 0
+        buffer[1] = m;  // 1
+        buffer[2] = m;  // 2
+        buffer[3] = m;  // 3
+        buffer[4] = m;  // 4
+        buffer[5] = m;  // 5
+        buffer[6] = m;  // 6
+        buffer[7] = m;  // 7
+        buffer[8] = m;  // 8
+        buffer[9] = m;  // 9
+        buffer[10] = m; // 10
+        buffer[11] = m; // 11
+        buffer[12] = m; // 12
+        buffer[13] = m; // 13
+        buffer[14] = m; // 14
+        buffer[15] = m; // 15
+#endif
+        SendOutData('t', ADDRESS_FC, 1, buffer, 16);
+        // hier könnte man noch eine I2C-Ausgabe einbauen...
+        lcd_frect (GX, GY, (m * 108) / 255, 10, 1);
+        write_ndigit_number_u (MX, MY, m, 3, 0);
+}
+//*****************************************************************************
+//
+void motor_test (void)
+{
+        //uint8_t m;
+        lcd_cls ();
+        m = 0;
+        lcd_printp (PSTR("Motor Test"), 0);
+        lcd_printpns_at (0, 7, PSTR("dec  inc    Exit Off"), 0);
+        if (hardware == NC && current_hardware == NC)
+        {
+                SwitchToFC();
+        }
+        motor (m);
+        do
+        {
+                if ((get_key_press (1 << KEY_PLUS) || get_key_rpt (1 << KEY_PLUS)) && (m < 254))
+                {
+                        m++;
+                }
+                if ((get_key_press (1 << KEY_MINUS) || get_key_rpt (1 << KEY_MINUS)) && (m > 0))
+                {
+                        lcd_frect (GX, GY, (m * 108) / 255, 10, 0);
+                        m--;
+                }
+                if (get_key_press (1 << KEY_ENTER))
+                {
+                        lcd_frect (GX, GY, (m * 108) / 255, 10, 0);
+                        m = 0;
+                }
+                motor (m);
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        // switch all engines off at exit !
+        motor (0);
+}

 /Transportables_Koptertool/trunk/motortest.h
 ,0 → 1,36
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _MOTORTEST_H
+#define _MOTORTEST_H
+//*****************************************************************************
+//
+#define MX 0
+#define MY 3
+#define GX (MX + 3) * 6 + 1     // 3 for 3 digits
+#define GY MY * 8 - 2
+#define MAXGX 128 - GX
+//*****************************************************************************
+//
+void motor_test (void);
+void motor_i2c (void);
+#endif

 /Transportables_Koptertool/trunk/osd.c
 ,0 → 1,501
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   based on the C-OSD code from CaScAdE                                    *
+ *                http://www.mylifesucks.de/oss/c-osd/                       *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <avr/pgmspace.h>
+#include "main.h"
+#include "osd.h"
+#include "lcd.h"
+#include "timer.h"
+#include "usart.h"
+#include "mk-data-structs.h"
+#define COSD_WASFLYING                          4
+/* ##########################################################################
+ * global definitions and global vars
+ * ##########################################################################*/
+NaviData_t *naviData;
+// stats for after flight
+int16_t max_Altimeter = 0;
+uint16_t max_GroundSpeed = 0;
+int16_t max_Distance = 0;
+uint8_t min_UBat = 255;
+uint16_t max_FlyingTime = 0;
+uint16_t max_Current = 0;
+uint16_t max_Capacity = 0;
+// cache old vars for blinking attribute, checkup is faster than full
+// attribute write each time
+volatile uint8_t last_UBat = 255;
+volatile uint8_t last_RC_Quality = 255;
+volatile uint16_t ftimer = 0;
+// store stats description in progmem to save space
+const char stats_item_0[] PROGMEM = "max Altitude:";
+const char stats_item_1[] PROGMEM = "max Speed   :";
+const char stats_item_2[] PROGMEM = "max Distance:";
+const char stats_item_3[] PROGMEM = "min Voltage :";
+const char stats_item_4[] PROGMEM = "max Time    :";
+#if 1
+const char stats_item_5[] PROGMEM = "max Current :";
+const char stats_item_6[] PROGMEM = "UsedCapacity:";
+#else
+const char stats_item_5[] PROGMEM = "Long. :";
+const char stats_item_6[] PROGMEM = "Lat.  :";
+#endif
+const char *stats_item_pointers[] PROGMEM = {
+        stats_item_0,
+        stats_item_1,
+        stats_item_2,
+        stats_item_3,
+        stats_item_4,
+        stats_item_5,
+        stats_item_6
+};
+//char* rose = "-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W-+-N-+-O-+-S-+-W";
+const char rose[48] PROGMEM = {
+x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S',
+x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N', 0x0e, 0x0f, 0x0e, 'O',
+x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W', 0x0e, 0x0f, 0x0e, 'N',
+x0e, 0x0f, 0x0e, 'O', 0x0e, 0x0f, 0x0e, 'S', 0x0e, 0x0f, 0x0e, 'W'};
+// the center is char 19 (north), we add the current heading in 8th
+// which would be 22.5 degrees, but float would bloat up the code
+// and *10 / 225 would take ages... so we take the uncorrect way
+const char str_NE[] PROGMEM = "NE";
+const char str_E[] PROGMEM  = "E ";
+const char str_SE[] PROGMEM = "SE";
+const char str_S[] PROGMEM  = "S ";
+const char str_SW[] PROGMEM = "SW";
+const char str_W[] PROGMEM  = "W ";
+const char str_NW[] PROGMEM = "NW";
+const char str_N[] PROGMEM  = "N ";
+const char *directions_p[8] PROGMEM = {
+        str_NE,
+        str_E,
+        str_SE,
+        str_S,
+        str_SW,
+        str_W,
+        str_NW,
+        str_N
+};
+// Flags
+uint8_t COSD_FLAGS2 = 0;
+/**
+ * convert the <heading> gotton from NC into an index
+ */
+uint8_t heading_conv (uint16_t heading)
+{
+        if (heading > 23 && heading < 68)
+        {
+                return 0;               //direction = "NE";
+        }
+        else if (heading > 67 && heading < 113)
+        {
+                return 1;               //direction = "E ";
+        }
+        else if (heading > 112 && heading < 158)
+        {
+                return 2;               //direction = "SE";
+        }
+        else if (heading > 157 && heading < 203)
+        {
+                return 3;               //direction = "S ";
+        }
+        else if (heading > 202 && heading < 248)
+        {
+                return 4;               //direction = "SW";
+        }
+        else if (heading > 247 && heading < 293)
+        {
+                return 5;               //direction = "W ";
+        }
+        else if (heading > 292 && heading < 338)
+        {
+                return 6;               //direction = "NW";
+        }
+        return 7;       //direction = "N ";
+}
+/**
+ * draw a compass rose at <x>/<y> for <heading>
+ */
+void draw_compass (uint8_t x, uint8_t y, uint16_t heading)
+{
+        uint8_t front = 19 + (heading / 22);
+        for (uint8_t i = 0; i < 9; i++)
+        {
+                lcd_putc (x++, y, pgm_read_byte(&rose[front - 4 + i]), 0);
+        }
+}
+/* ##########################################################################
+ * variometer
+ * ##########################################################################*/
+/**
+ * draw variometer arrows at <x>/<y> according to <variometer>
+ */
+void draw_variometer (uint8_t x, uint8_t y, uint8_t width_x, uint8_t width_y, int16_t variometer)
+{
+        lcd_rect (x, y - ((width_y - 1) / 2), width_x, width_y, 1);
+        lcd_frect (x + 1, y - ((width_y - 1) / 2) + 1, width_x - 2, width_y - 2, 0);
+        lcd_line (x, y, x + width_x, y, 1);
+        if (variometer > 0)
+        { // gain height
+                switch (variometer / 5)
+                {
+                        case 0:
+                                lcd_frect (x + 3, y - 1, 3, 1, 1);
+                                break;
+                        case 1:
+                                lcd_frect (x + 2, y - 3, 5, 3, 1);
+                                break;
+                        case 2:
+                                lcd_frect (x + 2, y - 4, 5, 4, 1);
+                                break;
+                        default:
+                                lcd_frect (x + 1, y - 5, 7, 5, 1);
+                                break;
+                }
+        }
+        else
+        { // sink
+                switch (variometer / -5)
+                {
+                        case 0:
+                                lcd_frect (x + 3, y, 3, 1, 1);
+                                break;
+                        case 1:
+                                lcd_frect (x + 2, y, 5, 3, 1);
+                                break;
+                        case 2:
+                                lcd_frect (x + 2, y, 5, 4, 1);
+                                break;
+                        default:
+                                lcd_frect (x + 1, y, 7, 5, 1);
+                                break;
+                }
+        }
+}
+#define TIMEOUT 200     // 2 sec
+void print_statistics (void)
+{
+        uint8_t line = 0;
+        lcd_cls ();
+        // max Altitude
+        lcd_printpns_at (0, line, stats_item_pointers[0], 0);
+        write_ndigit_number_s (13, line, max_Altimeter / 30, 4, 0);
+        lcd_putc (17, line, 'm', 0);
+        // max Speed
+        lcd_printpns_at (0, ++line, stats_item_pointers[1], 0);
+        write_ndigit_number_u (14, line, (uint16_t) (((uint32_t) max_GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);
+        lcd_printpns_at(17, line, PSTR("km/h"), 0);
+        // max Distance
+        lcd_printpns_at (0, ++line, stats_item_pointers[2], 0);
+        write_ndigit_number_u (14, line, max_Distance / 10, 3, 0);
+        lcd_putc (17, line, 'm', 0);
+        // max time
+        lcd_printpns_at (0, ++line, stats_item_pointers[4], 0);
+        write_time (13, line, max_FlyingTime);
+        // min voltage
+        lcd_printpns_at (0, ++line, stats_item_pointers[3], 0);
+        write_ndigit_number_u_10th (13, line, min_UBat, 3, 0);
+        lcd_putc (17, line, 'V', 0);
+#if 1
+        // max Current
+        lcd_printpns_at (0, ++line, stats_item_pointers[5], 0);
+        write_ndigit_number_u_10th (13, line, max_Current, 3, 0);
+        lcd_putc (17, line, 'A', 0);
+        // Used Capacity
+        lcd_printpns_at (0, ++line, stats_item_pointers[6], 0);
+        write_ndigit_number_u (13, line, max_Capacity, 4, 0);
+        lcd_printpns_at(17, line, PSTR("mAh"), 0);
+#else
+        // longitude
+        lcd_printpns_at (0, ++line, stats_item_pointers[5], 0);
+        write_gps_pos (8, line, naviData->CurrentPosition.Longitude);
+        // latitude
+        lcd_printpns_at (0, ++line, stats_item_pointers[6], 0);
+        write_gps_pos (8, line, naviData->CurrentPosition.Latitude);
+#endif
+        while (!get_key_press (1 << KEY_ESC))
+                timer = TIMEOUT;
+        COSD_FLAGS2 &= ~COSD_WASFLYING;
+        get_key_press(KEY_ALL);
+        lcd_cls();
+}
+void osd (void)
+{
+        uint8_t flag;
+        uint8_t tmp_dat;
+        // Clear statistics
+        max_Altimeter = 0;
+        max_GroundSpeed = 0;
+        max_Distance = 0;
+        min_UBat = 255;
+        max_FlyingTime = 0;
+        // flags from last round to check for changes
+        uint8_t old_FCFlags = 0;
+        uint16_t old_hh = 0;
+        lcd_cls();
+        if (hardware == FC)
+        {
+                lcd_printp_at(0, 3, PSTR("Only with NC !"), 0);
+                timer = 100;
+                while (timer > 0);
+        }
+        SwitchToNC();
+        mode = 'O';
+        // disable debug...
+        //      RS232_request_mk_data (0, 'd', 0);
+        tmp_dat = 0;
+        SendOutData ('d', ADDRESS_ANY, 1, &tmp_dat, 1);
+        // request OSD Data from NC every 100ms
+        //      RS232_request_mk_data (1, 'o', 100);
+        tmp_dat = 10;
+        SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
+        flag = 0;
+        timer = TIMEOUT;
+        abo_timer = ABO_TIMEOUT;
+        do
+        {
+                if (rxd_buffer_locked)
+                {
+                        timer = TIMEOUT;
+                        Decode64 ();
+                        naviData = (NaviData_t *) pRxData;
+                        flag = 1;
+                        if (naviData->FCFlags & FCFLAG_MOTOR_RUN)
+                        { // should be engines running
+                                // motors are on, assume we were/are flying
+                                COSD_FLAGS2 |= COSD_WASFLYING;
+                        }
+                        else
+                        {       // stats
+                                if ((COSD_FLAGS2 & COSD_WASFLYING) || (get_key_press (1 << KEY_ENTER)))
+                                {
+                                        print_statistics ();
+                                }
+                        }
+//                      lcd_printpns_at (0, 3, PSTR("012345678901234567890"), 0);
+                        lcd_ecircle(22, 35, 16, 1);
+                        // Ground Speed
+                        write_ndigit_number_u (1, 0, (uint16_t) (((uint32_t) naviData->GroundSpeed * (uint32_t) 9) / (uint32_t) 250), 3, 0);
+                        lcd_printpns_at(4, 0, PSTR("km/h"), 0);
+                        // Compass
+                        write_ndigit_number_u (14, 0, naviData->CompassHeading, 3, 0);
+                        lcd_putc (17, 0, 0x1E, 0);      // degree symbol
+                        lcd_printpns_at (18, 0, (const char *) (pgm_read_word ( &(directions_p[heading_conv(naviData->CompassHeading)]))), 0);
+                        draw_compass (12, 1, naviData->CompassHeading);
+                        // Altitude
+                        //note:lephisto:according to several sources it's /30
+                        if (naviData->Altimeter > 300 || naviData->Altimeter < -300)
+                        {
+                                // above 10m only write full meters
+                                write_ndigit_number_s (0, 1, naviData->Altimeter / 30, 4, 0);
+                        }
+                        else
+                        {
+                                // up to 10m write meters.dm
+                                write_ndigit_number_s_10th (0, 1, naviData->Altimeter / 3, 3, 0);
+                        }
+                        lcd_putc (4, 1, 'm', 0);
+                        draw_variometer (55, 7, 9, 13, naviData->Variometer);
+                        // TODO: verify correctness
+                        uint16_t heading_home = (naviData->HomePositionDeviation.Bearing + 360 - naviData->CompassHeading) % 360;
+                        lcd_ecirc_line (22, 35, 15, old_hh, 0);
+                        old_hh = heading_home;
+                        lcd_ecirc_line (22, 35, 15, heading_home, 1);
+                        write_ndigit_number_u (7, 3, heading_home, 3, 0);
+                        lcd_putc (10, 3, 0x1e, 0);      // degree symbol
+                        write_ndigit_number_u (7, 2, naviData->HomePositionDeviation.Distance / 10, 3, 0);
+                        lcd_putc (10, 2, 'm', 0);
+                        // Sats in use
+                        lcd_printp_at(10, 4, PSTR("Sats"), 0);
+                        write_ndigit_number_u (8, 4, naviData->SatsInUse, 2, 0);
+                        if (naviData->NCFlags & NC_FLAG_MANUAL_CONTROL)
+                        {
+                                lcd_putc (19, 4, 'M', 0); // rc transmitter
+                        }
+                        else
+                        {
+                                lcd_putc (19, 4, ' ', 0); // clear
+                        }
+#if 0
+                        lcd_printp_at(11, 5, PSTR("Mode:"), 0);
+                        if (naviData->NCFlags & NC_FLAG_CH)
+                        {
+                                lcd_printpns_at (17, 5, PSTR("CH  "), 0);
+                        }
+                        else if (naviData->NCFlags & NC_FLAG_PH)
+                        {
+                                lcd_printpns_at (17, 5, PSTR("PH  "), 0);
+                        }
+                        else
+                        { // (naviData->NCFlags & NC_FLAG_FREE)
+                                lcd_printpns_at (17, 5, PSTR("Free"), 0); // sat2 (free)
+                        }
+#endif
+                        if (naviData->NCFlags & NC_FLAG_CH)
+                        {
+                                lcd_printpns_at (10, 5, PSTR("Coming Home"), 0);
+                        }
+                        else if (naviData->NCFlags & NC_FLAG_PH)
+                        {
+                                lcd_printpns_at (10, 5, PSTR("Pos. Hold  "), 0);
+                        }
+                        else
+                        { // (naviData->NCFlags & NC_FLAG_FREE)
+                                lcd_printpns_at (10, 5, PSTR("Free       "), 0);
+                        }
+                        // Flying time
+                        write_time (7, 6, naviData->FlyingTime);
+//                      lcd_printp_at (7, 6, PSTR("Fly"), 0);
+                        // RC
+                        write_ndigit_number_u (15, 6, naviData->RC_Quality, 3, 0);
+                        lcd_putc (18, 6, 0x1F, 0);                      // RC-transmitter
+                        if (naviData->NCFlags & NC_FLAG_NOSERIALLINK)
+                        {
+                                lcd_printpns_at(19, 6, PSTR("  "), 0);          // clear
+                        }
+                        else
+                        {
+                                lcd_printpns_at(19, 6, PSTR("PC"), 0);
+                        }
+                        // Battery level
+                        write_ndigit_number_u_10th (0, 7, naviData->UBat, 3, 0);
+                        lcd_putc (4, 7, 'V', 0);
+                        // Current
+                        write_ndigit_number_u_10th (7, 7, naviData->Current, 3, 0);
+                        lcd_putc (11, 7, 'A', 0);
+                        // Capacity
+                        write_ndigit_number_u (14, 7, naviData->UsedCapacity, 4, 0);
+                        lcd_printpns_at(18, 7, PSTR("mAh"), 0);
+                        // remember statistics (only when engines running)
+                        if (naviData->FCFlags & FCFLAG_MOTOR_RUN)
+                        {
+                                if (naviData->Altimeter > max_Altimeter) max_Altimeter = naviData->Altimeter;
+                                if (naviData->GroundSpeed > max_GroundSpeed) max_GroundSpeed = naviData->GroundSpeed;
+                                if (naviData->HomePositionDeviation.Distance > max_Distance) max_Distance = naviData->HomePositionDeviation.Distance;
+                                if (naviData->UBat < min_UBat) min_UBat = naviData->UBat;
+                                if (naviData->FlyingTime > max_FlyingTime) max_FlyingTime = naviData->FlyingTime;
+                                if (naviData->Current > max_Current) max_Current = naviData->Current;
+                                if (naviData->UsedCapacity > max_Capacity) max_Capacity = naviData->UsedCapacity;
+                        }
+                        // remember last values
+                        last_RC_Quality = naviData->RC_Quality;
+                        last_UBat = naviData->UBat;
+                        old_FCFlags = naviData->FCFlags;
+                        rxd_buffer_locked = FALSE;
+                }
+                if (!abo_timer)
+                {       // renew abo every 3 sec
+                        // request OSD Data from NC every 100ms
+                        //      RS232_request_mk_data (1, 'o', 100);
+                        tmp_dat = 10;
+                        SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
+                        abo_timer = ABO_TIMEOUT;
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC) && timer);
+        get_key_press(KEY_ALL);
+        // disable OSD Data from NC
+        //      RS232_request_mk_data (1, 'o', 0);
+        tmp_dat = 0;
+        SendOutData ('o', ADDRESS_NC, 1, &tmp_dat, 1);
+        mode = 0;
+        rxd_buffer_locked = FALSE;
+        if (!timer)
+        {       // timeout occured
+                if (flag)
+                {
+                        lcd_cls ();
+                }
+                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                timer = 100;
+                while (timer > 0);
+                print_statistics ();
+        }
+}

 /Transportables_Koptertool/trunk/osd.h
 ,0 → 1,29
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   based on the C-OSD code from CaScAdE                                    *
+ *                http://www.mylifesucks.de/oss/c-osd/                       *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _OSD_H
+#define _OSD_H
+//*****************************************************************************
+//
+void osd (void);
+#endif

 /Transportables_Koptertool/trunk/parameter.c
 ,0 → 1,687
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <util/delay.h>
+#include <string.h>
+#include <stdlib.h>
+#include "main.h"
+#include "lcd.h"
+#include "timer.h"
+#include "usart.h"
+#include "parameter.h"
+#include "menu.h"
+#include "mk-data-structs.h"
+#define TIMEOUT 500     // 5 sec
+mk_param_struct_t *mk_param_struct;
+uint8_t array[8];
+prog_uchar p_menus[12][11]=
+{
+        "Config    ",
+        "Channels  ",
+        "Stick     ",
+        "Hight     ",
+        "Gyro      ",
+        "Looping   ",
+        "Camera    ",
+        "Misc.     ",
+        "User      ",
+        "Coupling  ",
+        "Config(2) ",
+        "Loopingset"
+};
+// Diese Tabelle ordnet die eingelesenen Parameter den Menü-Seiten zu
+prog_uchar p_menu_number[67]=
+{
+, 2, 2, 2, 2, 2, 2, 2,                         // Die ersten 8 Parameter werden auf Menüseite 2 angezeigt (=Kanalzuordnungen)
+, 4, 4, 4, 4, 4, 4, 3,
+, 3, 8, 8, 8, 8, 5, 5,
+,8,8,0,5,9,9,9,
+,7,7,7,7,7,7,6,
+,6,10,10,6,6,5,5,
+,9,9,9,9,0,7,11,
+,11,11,12,12, 12,
+,12,12,12,12
+};
+prog_uchar p_limits[199]=                                               // Limits f¸r die Parameter
+{
+,8,2,                  // 2:Nick                                       (3)
+,8,2,                  // 2:Roll                                       (4)
+,8,2,                  // 2:Gas                                        (2)
+,8,2,                  // 2:Gier                                       (1)
+,8,2,                  // 2:Poti1                                      (6)
+,8,2,                  // 2:Poti2                                      (6)
+,8,2,                  // 2:Poti3                                      (7)
+,8,2,                  // 2:Poti4                                      (5)
+,0,0,                  // 1:Config
+,255,4,                // 4:Höhe MinGas                       (30)
+,255,4,                // 4:Luftdruck_D                        (30)
+,255,4,                // 4:MaxHöhe (Setpoint?)       (Poti4)
+,255,4,                // 4:Höhe_P                                    (10)
+,50,4,                 // 4:Höhe Verst‰rkung                (3)
+,255,4,                // 4:Höhe Z-acc                                (30)
+,6,3,                  // 3:Nick/Roll P                        (3)
+,64,3,                 // 3:Nick/Roll D                        (4)
+,20,3,                 // 3:Gier_P                                     (6)
+,32,8,                 // 8:Min.Gas                            (15)
+,250,8,               // 8:Max.Gas                            (250)
+,50,8,         // 5:Gyro-Acc Faktor                    (30)
+,255,8,                // 8:Kompass-Wirkung            (128)
+,0,5,                  // 5:Gyro-P                                     (80)
+,0,5,                  // 5:Gyro-I                                     (120)
+,250,8,                // 8:Unterspannung                      (94)
+,250,8,                // 8:Not-Gas Zeit                       (20)
+,250,8,                // 8:Not-Gas                            (35)
+,1,0,                  // Ufo-Ausrichtung (X +)
+,255,5,                // I-Faktor                                     (32)
+,255,9,                // 9:User1                                      (80)
+,255,9,                // 9:User2                                      (0)
+,255,9,                // 9:User3
+,255,9,                // 9:User4
+,255,7,                // 7:Servo Nick Control         (100)
+,250,7,                // 7:Servo Nick Compensation    (40)
+,250,7,                // 7:Servo Nick min                     (50)
+,250,7,                // 7:Servo Nick max                     (150)
+,25,7,                 // 7:Servo Nick refrsh          (5)
+,255,6,                // 6:Loop Gas Limit                     (50)
+,250,6,                // 6:Loop Ansprechschwelle      (90)
+,250,6,                // 6:Loop Hysterese                     (50)
+,255,10,               // 10:Achskopplung                      (90)
+,255,10,               // 10:Achsgegenkopplung         (5)
+,250,6,                // 6:Turnover Nick                      (100)
+,250,6,                // 6:Turnover Roll                      (100)
+,250,5,                // 5: Gyro-Abgleich (Comp.)             (32)
+,250,5,                // 5: Drift                                             (4)
+,255,5,                // 5: Dynamic stability                 (75)
+,255,9,                // 9:User5
+,255,9,                // 9:User6
+,255,9,                // 9:User7
+,255,9,                // 9:User8                                      (0)
+,0,1,                  // 6:Loop Config                        (0)
+,1,7                   // 7:Servo Nick Compensation Invert (0)
+};
+prog_char bin_parameter[12][16] =                                                       // Die bin‰r kodierten Parametern werden getrennt behandelt.
+{
+        "Loop up        ",
+        "Loop down          ",
+        "Loop left      ",
+        "Loop right     ",
+        "Höhenregler    ",             // 8
+        "Höhenschalter  ",
+        "Headhold               ",
+        "Kompass                ",
+        "KompassFix             ",
+        "GPS                    ",
+        "Achsenkopplung ",
+        "Drehrate               "
+};
+prog_char parameter[54][16]=
+{
+        "Nick           ",              // 0    (3)
+        "Roll           ",              // 1    (4)
+        "Gas            ",              //              (2)
+        "Gier                   ",              //              (1)
+        "Poti1                  ",              //              (6)
+        "Poti2                  ",              //              (6)
+        "Poti3                  ",              //              (7)
+        "Poti4                  ",              //      7       (5)
+        "Config                 ",              //      8
+        "Höhe_MinGas   ",              // 9    (30)
+        "Luftdruck_D    ",              // 10 Wert : 0-250              (30)
+        "MaxHöhe       ",              // 11 Wert : 0-250   251 -> Poti1 (Poti4)
+        "Höhe_P        ",              // 12 Wert : 0-32               (10)
+        "Höhe_Verstaerk",              // 13 Wert : 0-50
+        "Höhe_ACC_Wirk.",              // 14 Wert : 0-250              (30)
+        "Stick_P        ",              // 15 Wert : 1-6
+        "Stick_D        ",              // 16 Wert : 0-64
+        "Gier_P         ",              // 17 Wert : 1-20       POTI(?)
+        "Gas_Min        ",              // 17 Wert : 0-32
+        "Gas_Max        ",              // 18 Wert : 33-250
+        "GyroAccFaktor  ",      // 19 Wert : 1-64
+        "KompassWirkung ",              // 20 Wert : 0-250
+        "Gyro_P                 ",              // 21 Wert : 0-250
+        "Gyro_I                 ",              // 22 Wert : 0-250
+        "Unterspannung  ",              // 23 Wert : 0-250
+        "NotGas                 ",              // 24 Wert : 0-250     // Gaswert bei Empangsverlust
+        "NotGasZeit     ",              // 25 Wert : 0-250     // Zeit bis auf NotGas geschaltet wird, wg. Rx-Problemen
+        "UfoAusrichtung ",              // 26 X oder + Formation
+        "I_Faktor       ",              // 27 = 32;
+        "UserParam1             ",              // 28 = 32 * 4;             //zur freien Verwendung
+        "UserParam2             ",      // 29 zur freien Verwendung
+        "UserParam3             ",              // 30 zur freien Verwendung
+        "UserParam4             ",              // 31 zur freien Verwendung
+        "ServoNickCtrl  ",              // 32 Wert : 0-250     // Stellung des Servos
+        "ServoNickComp  ",              // 33 Wert : 0-250     // Einfluss Gyro/Servo
+        "ServoNickMin   ",              // 34 Wert : 0-250     // Anschlag
+        "ServoNickMax   ",              // 35 Wert : 0-250     // Anschlag
+        "ServoNickRefrsh",              // 36
+        "LoopGasLimit   ",              // 37
+        "LoopThreshold  ",              // 38 Wert: 0-250  Schwelle f¸r Stickausschlag
+        "LoopHysterese  ",              // 39
+        "AchsKopplung   ",              // 40
+        "AchsGegenKoppl.",              // 41
+        "WinklUmschlNick",              // 42
+        "WinklUmschlRoll",              // 43
+        "GyroAccAbgleich",      // 44  1/k
+        "Driftkomp              ",              // 45
+        "DynamicStabilit",              // 47
+        "UserParam5             ",              // 48 zur freien Verwendung
+        "UserParam6             ",              // 49 zur freien Verwendung
+        "UserParam7             ",              // 50 zur freien Verwendung
+        "UserParam8             ",              // 51 zur freien Verwendung
+        "LoopConfig             ",              // 52  Bitcodiert: 0x01=oben, 0x02=unten, 0x04=links, 0x08=rechts / wird getrennt behandelt
+        "ServoNickCompIn"               // 53 Wert : 0-250     // Richtung Einfluss Gyro/Servo
+//      "Name           "               // 54
+};
+void binary (uint8_t data, uint8_t *feld)                       // Wandelt eine 8-Bit Zahl in eine Bin‰rzahl um (Array mit 8 Elementen)
+{                                                                                                               // Wird f¸r die Flags (Loop + Grundkonfiguration) benˆtigt
+        uint8_t i;
+        i=0;
+        for (i = 0; i < 8; i++)
+        {
+                if ((1 << i) & data)
+                        feld[i] = 1;
+                else
+                        feld[i] = 0;
+        }
+}
+uint8_t bindec (uint8_t *feld)                                          // wandelt eine Bin‰rzahl (im Array) in eine 8-Bit Zahl
+{                                                                                                               // Wird f¸r die Flags (Loop + Grundkonfiguration) benˆtigt
+        uint8_t i;
+        uint8_t result;
+        result = 0;
+        for (i = 0; i < 8; i++)
+        {
+                if (feld[i] == 1)
+                        result += 1 << i;
+        }
+        return result;
+}
+void decimal (uint8_t data, uint8_t *text)                      // wandelt Wert in rechtsbündigen Text um
+{                                                                                                               // (schneller/kleiner als printf())
+        text[0] = data/100;
+        data -= (text[0] * 100);
+        text[1] = data/10;
+        data -= (text[1] *10);
+        text[2] = data + 0x30;
+        text[0] += 0x30;
+        text[1] += 0x30;
+        if (text[0] == 0x30)
+        {
+                text[0] = 0x20;
+                if (text[1] == 0x30)
+                        text[1] = 0x20;
+        }
+        text[3] = 0x00;
+}
+uint8_t show_parameter (uint8_t number)                                                 // Zeigt eine Parameter-Seite an und gibt die ausgew‰hlte Zeile zur¸ck
+{
+#if 0
+        uint8_t i;
+        uint8_t line;
+        uint8_t text[25];
+        uint8_t bin[8];
+        line = 0;
+        if (number > 1)
+        {
+                for (i = 0; i<66; i++)
+                {
+                        if (pgm_read_byte(p_limits+i*3+2) == number)
+                        {
+                                array[line] = i;
+                                decimal(buffer[i],text);
+                                lcd_print_at(0,line,text,0);
+                                lcd_printp_at (5,line,parameter[i],0);
+                                if (line <= 7)
+                                        line++;
+                        }
+                }
+        }
+        else
+        {                                                                                                                               // Sonderf‰lle: Bin‰re Eingabe
+                if (number == 1)
+                {
+                        binary(buffer[52],bin);                                                         // Loop-Config
+                        text[1] = 0x00;
+                        for (i = 0; i < 4; i++)
+                        {
+                                text[0] = bin[i] + 0x30;
+                                lcd_print_at (0, i, text, 0);
+                                lcd_printp_at (5, i, bin_parameter[i], 0);
+                        }
+                }
+                if (number == 0)
+                {
+                        binary (buffer[8], bin);                                                                // Config
+                        text[1] = 0x00;
+                        for (i = 0; i < 8; i++)
+                        {
+                                text[0] = bin[i] + 0x30;
+                                lcd_print_at (0, i, text, 0);
+                                lcd_printp_at (5, i, bin_parameter[i + 4], 0);
+                        }
+                }
+        }
+        return line;
+#endif
+}
+void edit_parameter2 (uint8_t page, uint8_t lines)                              // ƒndern der Parameter einer Seite
+{
+#if 0
+        uint8_t line;
+        uint8_t par;
+        uint8_t min;
+        uint8_t max;
+        uint8_t text[10];
+        uint8_t bin[8];
+        if (page > 1)                                                                                                   // "normale" Parameter-Seiten
+        {
+                line = menu_choose(0,lines-1,4);
+                if (line != 255)                                                                                // Wenn line == 255, wurde Escape gedr¸ckt
+                {
+                        par = buffer[array[line]];
+                        min = pgm_read_byte(p_limits + par * 3);
+                        max = pgm_read_byte(p_limits + par * 3 + 1);
+                        lcd_printp_at(4,line,PSTR("-"),0);
+                        while (key != key_nokey);
+                        do
+                        {
+                                if (key == key_minus)
+                                {
+                                        //if (par > min)                                                        // ‹berpr¸fung der Parameter auf Bereichs¸berschreitung derzeit deaktiviert
+                                                par --;
+                                }
+                                if (key == key_plus)
+                                {
+                                        //if (par < max)
+                                                par ++;
+                                }
+                                decimal(par,text);
+                                lcd_print_at(0,line,text,0);
+                                timer = 20;
+                                while (timer > 0);
+                        }
+                        while ((key != 0x04) && (key != 0x08));
+                        if (key == 0x08)
+                                buffer[array[line]] = par;
+                }
+        }
+        if (page == 1)                                                                                  // Spezialfall:  Loop-Config (einzelne Bits setzen / lˆschen)
+        {
+                binary(buffer[52],bin);
+                text[1] = 0x00;
+                line = menu_choose(0,3,4);
+                if (line != 255)                                                                        // Wenn line == 255, wurde Escape gedr¸ckt
+                {
+                        par = bin[line];
+                        lcd_printp_at(4,line,PSTR("-"),0);
+                        do
+                        {
+                                if (key == key_minus)
+                                {
+                                        par = 0x00;
+                                }
+                                if (key == key_plus)
+                                {
+                                        par = 0x01;
+                                }
+                                text[0] = par+0x30;
+                                lcd_print_at(0,line,text,0);
+                                timer = 20;
+                                while (timer > 0);
+                        }
+                        while ((key != key_enter) && (key != key_esc));
+                        if (key == key_enter)
+                        {
+                                bin[line] = par;
+                                buffer[52] = bindec(bin);
+                        }
+                        lcd_cls();
+                        decimal(buffer[52],text);
+                        lcd_print(text,0);
+                        timer = 200;
+                        while(timer > 0);
+                }
+        }
+        if (page == 0)                                                                                                  // Spezialfall: Allgemeine Konfiguration (einzelne Bits setzen/lˆschen)
+        {
+                binary(buffer[8],bin);
+                text[1] = 0x00;
+                line = menu_choose(0,7,4);
+                if (line != 255)                                                                                        // Wenn line == 255, wurde Escape gedr¸ckt
+                {
+                        par = bin[line];
+                        lcd_printp_at(4,line,PSTR("-"),0);
+                        do
+                        {
+                                if (key == key_minus)
+                                {
+                                        par = 0x00;
+                                }
+                                if (key == key_plus)
+                                {
+                                        par = 0x01;
+                                }
+                                text[0] = par+0x30;
+                                lcd_print_at(0,line,text,0);
+                                timer = 20;
+                                while (timer > 0);
+                        }
+                        while ((key != key_enter) && (key != key_esc));
+                        if (key == key_enter)
+                        {
+                                bin[line] = par;
+                                buffer[8] = bindec(bin);
+                        }
+                        lcd_cls();
+                        decimal(buffer[8],text);
+                        lcd_print(text,0);
+                        timer = 200;
+                        while(timer > 0);
+                }
+        }
+#endif
+}
+void edit_parameter1 (void)
+{
+        uint8_t cmd;
+        uint8_t setting = 0xff;
+        mode = 'P';     // Settings
+        lcd_cls ();
+        //mode = 'Q';   // Settings
+        _delay_ms (50);
+        rxd_buffer_locked = FALSE;
+        timer = TIMEOUT;
+        LED2_ON;
+        //SendOutData ('q', ADDRESS_FC, 1, &setting, 1);
+        SendOutData ('p', ADDRESS_FC, 1);
+        while (!rxd_buffer_locked && timer);
+        if (timer)
+        {
+                LED3_ON;
+                Decode64 ();
+#if 0
+                mk_param_struct = (mk_param_struct_t *) pRxData + 2;
+                lcd_printp (PSTR("Current Setting: "), 0);
+                lcd_write_number_u (*pRxData);
+                lcd_printp (PSTR("Setting Version: "), 0);
+                lcd_write_number_u (*pRxData+1);
+#endif
+                LED3_OFF;
+        }
+        else
+        {       // timeout occured
+                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                timer = 100;
+                while (timer > 0);
+                return;
+        }
+        LED2_OFF;
+        // after all work is done...
+        rxd_buffer_locked = FALSE;
+#if 0
+        uint8_t page;                                                           // 12 Pages
+        uint8_t text[15];
+        uint8_t lines;
+        uint8_t parameter;
+        lcd_cls ();
+        lcd_printp (PSTR("Load Setting\r\n"), 0);
+        lcd_printp (PSTR(" 1:\r\n"), 0);
+        lcd_printp (PSTR(" 2:\r\n"), 0);
+        lcd_printp (PSTR(" 3:\r\n"), 0);
+        lcd_printp (PSTR(" 4:\r\n"), 0);
+        lcd_printp (PSTR(" 5:\r\n"), 0);
+        parameter = menu_choose (1, 5, 0);
+        page = 2;
+        if (read_parameter (parameter) == 1)
+        {
+                lcd_printp_at (0, 6, PSTR("Timeout"), 0);
+        }
+        else
+        {
+                do
+                {
+                        lcd_cls ();
+                        utoa (page, text, 10);
+                        lcd_print (text, 0);
+                        timer = 50;
+                        while (timer > 0);
+                        lcd_cls ();
+                        lines = show_parameter (page);
+                        while (key == key_nokey);
+                        if (key == key_plus)
+                                page++;
+                        if (key == key_minus)
+                                page--;
+                        if (page == 255)
+                                page = 12;
+                        if (page > 12)
+                                page = 0;
+                        if (key == key_enter)
+                                edit_parameter2 (page, lines);
+                }
+                while (key != key_esc);
+                lcd_cls ();
+                lcd_printp (PSTR("Parameter speichern?\r\n  ja\r\n  nein"), 0);
+                lines = menu_choose (1, 2, 0);
+                if (lines == 1 )
+                {
+                        lcd_printp (PSTR("\r\n--->"), 0);
+                        write_parameter (5);            // Sicherheitshalber wird derzeit ausschlieﬂlich auf Parametersatz 5 gesichert.
+                        lcd_printp (PSTR("\r\nParameter gespeichert"), 0);
+                }
+                else
+                {
+                        lcd_printp (PSTR("\r\nNicht gespeichert"), 0);
+                }
+        }
+        timer = 100;
+        while (timer > 0);
+#endif
+}
+void display_page (uint8_t page)
+{
+        lcd_cls ();
+        switch (page)
+        {
+                case 0:
+                        lcd_printp (PSTR("Current Setting: "), 0);
+                        lcd_write_number_u (*pRxData);
+                        lcd_printp (PSTR("\r\nSetting Version: "), 0);
+                        lcd_write_number_u (*(pRxData + 1));
+#if 0
+                        lcd_printp (PSTR("\r\nRxDataLen: "), 0);
+                        lcd_write_number_u (RxDataLen);
+                        lcd_printp (PSTR("\r\nRxBytes: "), 0);
+                        lcd_write_number_u (ReceivedBytes);
+#endif
+                        break;
+                case 1:
+                        lcd_printp (PSTR("Pitch: "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[0]);
+                        lcd_printp (PSTR("Yaw  : "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[1]);
+                        lcd_printp (PSTR("Nick : "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[2]);
+                        lcd_printp (PSTR("Roll : "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[3]);
+                        lcd_printp (PSTR("Poti1: "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[4]);
+                        lcd_printp (PSTR("Poti2: "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[5]);
+                        lcd_printp (PSTR("Poti3: "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[6]);
+                        lcd_printp (PSTR("Poti4: "), 0);
+                        lcd_write_number_u (mk_param_struct->Kanalbelegung[7]);
+                        break;
+        }
+}
+void edit_parameter (void)
+{
+        uint8_t cmd;
+        uint8_t sett = 0xff;    // current active parameter set
+        uint8_t page = 0;
+        SwitchToFC();
+        mode = 'Q';     // Settings
+        lcd_cls ();
+        _delay_ms (50);
+        rxd_buffer_locked = FALSE;
+        timer = TIMEOUT;
+        SendOutData ('q', ADDRESS_FC, 1, &sett, 1);
+        while (!rxd_buffer_locked && timer);
+        if (timer)
+        {
+                Decode64 ();
+                mk_param_struct = (mk_param_struct_t *) pRxData + 2;
+                display_page (page);
+                if (get_key_press (1 << KEY_MINUS))
+                {
+                        page--;
+                }
+                else if (get_key_press (1 << KEY_PLUS))
+                {
+                        page++;
+                }
+        }
+        else
+        {       // timeout occured
+                lcd_printp_at (0, 2, PSTR("ERROR: no data"), 0);
+                timer = 100;
+                while (timer > 0);
+                return;
+        }
+        // after all work is done...
+        //rxd_buffer_locked = FALSE;
+        while (!get_key_press (1 << KEY_ESC));  // ESC
+        mode = 0;
+        rxd_buffer_locked = FALSE;
+}

 /Transportables_Koptertool/trunk/parameter.h
 ,0 → 1,29
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _PARAMETER_H
+#define _PARAMETER_H
+//*****************************************************************************
+//
+void edit_parameter (void);
+void decimal (uint8_t data, uint8_t *text);
+#endif

 /Transportables_Koptertool/trunk/servo.c
 ,0 → 1,128
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include "lcd.h"
+#include "timer.h"      // Keys
+#include "servo.h"
+#define SERVO_MIN                       313     // 1.0 ms (Servo min)
+#define SERVO_MAX                       625     // 2.0 ms (Servo max)
+#define SERVO_CENTER    469     // 1.5 ms
+#define SERVO_PULSE     6250    // 20 ms
+//*****************************************************************************
+//
+ISR(TIMER1_COMPA_vect)
+{
+        PORTD |= (1 << PD7);
+}
+//*****************************************************************************
+//
+ISR(TIMER1_COMPB_vect)
+{
+        PORTD &= ~(1 << PD7);
+}
+//*****************************************************************************
+//
+void servo_test (void)
+{
+        uint8_t chg = 0;
+        uint8_t step = 10;
+        DDRD |= (1 << DDD7);    // PD7 output
+        TCCR1B = (1 << WGM12) | (1 << CS11) | (1 << CS10); // Prescaler 1/64, CTC mode
+                                                                                                                                                                                                                 // 1 step = 3,2 µs (@ 20 MHz)
+        OCR1A = SERVO_PULSE;
+        OCR1B = SERVO_CENTER;
+        TIMSK1 = (1 << OCIE1A) | (1 << OCIE1B);
+        lcd_cls ();
+        lcd_printp (PSTR("Servo Tester"), 0);
+        //lcd_printpns_at (0, 7, PSTR("-1   +1     Exit  \x1d\x7c\x1c"), 0);
+        lcd_printpns_at (0, 7, PSTR("-10  +10    Exit  \x1d\x7c\x1c"), 0);
+        lcd_frect (SGX, SGY, ((OCR1B - SERVO_MIN) * SMAXGX) / (SERVO_MAX - SERVO_MIN), 10, 1);
+        //write_ndigit_number_u (SMX, SMY, ((OCR1B - SERVO_MIN) * 100) / (SERVO_MAX - SERVO_MIN), 3, 0);        // Pulse width in %
+        write_ndigit_number_u_100th(SMX, SMY, (OCR1B * 64) / 200 , 3, 0);       // Pulse width in ms
+        do
+        {
+                if ((get_key_press (1 << KEY_PLUS) || get_key_rpt (1 << KEY_PLUS)) && (OCR1B < SERVO_MAX))
+                {
+                        OCR1B += step;
+                        if (OCR1B > SERVO_MAX)
+                        {
+                                OCR1B = SERVO_MAX;
+                        }
+                        chg++;
+                }
+                else if ((get_key_press (1 << KEY_MINUS) || get_key_rpt (1 << KEY_MINUS)) && (OCR1B > SERVO_MIN))
+                {
+                        lcd_frect (SGX, SGY, ((OCR1B - SERVO_MIN) * SMAXGX) / (SERVO_MAX - SERVO_MIN), 10, 0);
+                        OCR1B -= step;
+                        if (OCR1B < SERVO_MIN)
+                        {
+                                OCR1B = SERVO_MIN;
+                        }
+                        chg++;
+                }
+                else if (get_key_short (1 << KEY_ENTER))
+                {
+                        lcd_frect (SGX, SGY, ((OCR1B - SERVO_MIN) * SMAXGX) / (SERVO_MAX - SERVO_MIN), 10, 0);
+                        OCR1B = SERVO_CENTER;
+                        chg++;
+                }
+                else if (get_key_long (1 << KEY_ENTER))
+                {
+                        if (step == 1)
+                        {
+                                step = 10;
+                                lcd_printpns_at (0, 7, PSTR("-10  +10    Exit  \x1d\x7c\x1c"), 0);
+                        }
+                        else
+                        {
+                                step = 1;
+                                lcd_printpns_at (0, 7, PSTR("-1   +1     Exit  \x1d\x7c\x1c"), 0);
+                        }
+                }
+                if (chg)
+                {
+                        chg = 0;
+                        lcd_frect (SGX, SGY, ((OCR1B - SERVO_MIN) * SMAXGX) / (SERVO_MAX - SERVO_MIN), 10, 1);
+                        //write_ndigit_number_u (SMX, SMY, ((OCR1B - SERVO_MIN) * 100) / (SERVO_MAX - SERVO_MIN), 3, 0);        // Pulse width in %
+                        write_ndigit_number_u_100th(SMX, SMY, (OCR1B * 64) / 200 , 3, 0);       // Pulse width in ms
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        get_key_press(KEY_ALL);
+        TIMSK1 = 0;
+}

 /Transportables_Koptertool/trunk/servo.h
 ,0 → 1,41
+/*****************************************************************************
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _SERVO_H
+#define _SERVO_H
+//*****************************************************************************
+//
+// text position
+#define SMX 0
+#define SMY 3
+// graphics position
+//#define SGX ((SMX + 3) * 6 + 1)       // 3 for 3 digits
+#define SGX ((SMX + 4) * 6 + 1) // 4 for 4 digits
+#define SGY (SMY * 8 - 2)
+#define SMAXGX (128 - SGX)
+//*****************************************************************************
+//
+void servo_test (void);
+#endif

 /Transportables_Koptertool/trunk/settings.c
 ,0 → 1,145
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/pgmspace.h>
+#include <avr/interrupt.h>
+#include "main.h"
+#include "menu.h"
+#include "lcd.h"
+#include "settings.h"
+#include "timer.h"
+#ifndef USE_MMT
+#include "lipo.h"
+#endif
+#include "eeprom.h"
+//*****************************************************************************
+//
+void set_toggledisplay(void)
+{
+        cli();
+        if (LCD_ORIENTATION == 0)
+                LCD_ORIENTATION = 4;
+        else
+                LCD_ORIENTATION = 0;
+        WriteParameter ();
+        LCD_Init();
+        sei();
+}
+//*****************************************************************************
+//
+void set_viewfont(void)
+{
+        uint8_t page;
+        page = 0;
+        lcd_view_font (page);
+        do
+        {
+                if (get_key_press (1 << KEY_PLUS) && (page < 1))
+                {
+                        page++;
+                        lcd_view_font (page);
+                }
+                if (get_key_press (1 << KEY_MINUS) && (page > 0))
+                {
+                        page--;
+                        lcd_view_font (page);
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        get_key_press(KEY_ALL);
+}
+//*****************************************************************************
+//
+#ifndef USE_MMT
+void set_lipo(void)
+{
+        lcd_cls();
+        lcd_printp_at(0, 0, PSTR("LiPo Under Voltage:"), 0);
+        lcd_printp_at(0, 2, PSTR("Warn Voltage: "), 0);
+        lcd_printpns_at (0, 7, PSTR(" -    +     Ok"), 0);
+        do
+        {
+                write_ndigit_number_u_10th(14, 2, AD_WarnLevel, 3, 0);
+                if (get_key_press (1 << KEY_PLUS) && (AD_WarnLevel < 40))
+                {
+                        AD_WarnLevel++;
+                }
+                else if (get_key_press (1 << KEY_MINUS) && (AD_WarnLevel > 20))
+                {
+                        AD_WarnLevel--;
+                }
+        }
+        while (!get_key_press (1 << KEY_ESC));
+        get_key_press(KEY_ALL);
+        WriteParameter ();
+}
+#endif
+// Not really usefull :-)
+// testing....
+//*****************************************************************************
+//
+void set_line(void)
+{
+        lcd_cls ();
+#if 1
+        lcd_line (10, 20, 100, 50, 1);          // draw a line
+#else
+        lcd_ecircle(22, 35, 18, 1);
+        uint16_t old_d = 0;
+        for (uint16_t i = 0; i < 360; i += 10)
+        {
+                lcd_ecirc_line (22, 35, 17, old_d, 0);
+                old_d = i;
+                lcd_ecirc_line (22, 35, 17, i, 1);
+                while (!get_key_press (1 << KEY_ENTER));
+        }
+#endif
+        while (!get_key_press (1 << KEY_ESC));
+}
+//*****************************************************************************
+//
+void set_rect(void)
+{
+        lcd_cls ();
+        //lcd_rect (10, 20, 100, 40, 1);                // draw a rect
+        //lcd_ellipse(60, 30, 23, 20, 1);
+        lcd_frect(10, 10, 20, -5, 1);
+        write_ndigit_number_s (10, 1, -10, 2, 0);
+        write_ndigit_number_s (10, 2, -10, 3, 0);
+        write_ndigit_number_s (10, 3, -10, 4, 0);
+        write_ndigit_number_s (10, 4, -10, 5, 0);
+        while (!get_key_press (1 << KEY_ESC));
+}

 /Transportables_Koptertool/trunk/settings.h
 ,0 → 1,36
+/*****************************************************************************
+ *   Copyright (C) 2008 Thomas Kaiser, thomas@ft-fanpage.de                  *
+ *   Copyright (C) 2009-2010 Peter "woggle" Mack, mac@denich.net             *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _SETTINGS_H
+#define _SETTINGS_H
+//*****************************************************************************
+//
+void set_toggledisplay(void);
+void set_viewfont(void);
+void set_line(void);
+void set_rect(void);
+#ifndef USE_MMT
+void set_lipo(void);
+#endif
+#endif

 /Transportables_Koptertool/trunk/status.c
 ,0 → 1,71
+/*****************************************************************************
+ *   Copyright (C) 2010 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include "lcd.h"
+#include "timer.h"      // Keys
+#include "usart.h"
+#include "status.h"
+#include "debug.h"
+//*****************************************************************************
+//
+void status (void)
+{
+        uint8_t line = 1;
+        lcd_cls ();
+        lcd_printp (PSTR("Status:"), 0);
+        lcd_printpns_at (0, 7, PSTR("            Back    "), 0);
+        lcd_printp_at(0, line, PSTR("MMB Version: "), 0);
+        lcd_write_number_u (VERSION_MAJOR);
+        lcd_printp(PSTR("."), 0);
+        lcd_write_number_u (VERSION_MINOR);
+        line++;
+        lcd_printp_at(0, line, PSTR("UART CRC ERR: "), 0);
+        write_ndigit_number_u(15, line, stat_crc_error, 5, 0);
+        line++;
+        lcd_printp_at(0, line, PSTR("UART OVEFLOW: "), 0);
+        write_ndigit_number_u(15, line, stat_overflow_error, 5, 0);
+        line++;
+#if defined (__AVR_ATmega32__)
+        lcd_printp_at(0, line, PSTR("Names: "), 0);
+        write_ndigit_number_u(15, line, AnalogNamesRead, 5, 0);
+        line++;
+#else
+        lcd_printp_at(0, line, PSTR("Names NC: "), 0);
+        write_ndigit_number_u(15, line, AnalogNamesRead[0], 5, 0);
+        line++;
+        lcd_printp_at(0, line, PSTR("AN FC: "), 0);
+        write_ndigit_number_u(15, line, AnalogNamesRead[1], 5, 0);
+        line++;
+#endif
+        while (!get_key_press (1 << KEY_ESC));
+}

 /Transportables_Koptertool/trunk/status.h
 ,0 → 1,30
+/*****************************************************************************
+ *   Copyright (C) 2010 Peter "woggle" Mack, mac@denich.net                  *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _STATUS_H
+#define _STATUS_H
+//*****************************************************************************
+//
+//*****************************************************************************
+//
+void status (void);
+#endif

 /Transportables_Koptertool/trunk/timer.c
 ,0 → 1,177
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   based on the key handling by Peter Dannegger                            *
+ *     see www.mikrocontroller.net                                           *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include "main.h"
+#include "timer.h"
+volatile uint16_t timer;
+volatile uint16_t abo_timer;
+uint8_t key_state = 0;  // debounced and inverted key state:
+                                                                                                // bit = 1: key pressed
+uint8_t key_press = 0;  // key press detect
+uint8_t key_rpt;                                // key long press and repeat
+//*****************************************************************************
+//
+#if defined (__AVR_ATmega32__)
+ISR(TIMER0_COMP_vect)                                           // Timer-Interrupt (100 Hz)
+#else
+ISR(TIMER0_COMPA_vect)                                  // Timer-Interrupt (100 Hz)
+#endif
+{
+  static uint8_t ct0 = 0;
+        static uint8_t ct1 = 0;
+        static uint8_t rpt = 0;
+        uint8_t i;
+        // Key handling by Peter Dannegger
+        // see www.mikrocontroller.net
+        i = key_state ^ ~KEY_PIN;       // key changed ?
+        ct0 = ~(ct0 & i);                                               // reset or count ct0
+        ct1 = ct0 ^ (ct1 & i);                  // reset or count ct1
+        i &= (ct0 & ct1);                                               // count until roll over ?
+        key_state ^= i;                                                 // then toggle debounced state
+        key_press |= (key_state & i);   // 0->1: key press detect
+        if ((key_state & REPEAT_MASK) == 0)     // check repeat function
+        {
+                rpt = REPEAT_START;     // start delay
+        }
+        if (--rpt == 0)
+        {
+                rpt = REPEAT_NEXT;      // repeat delay
+                key_rpt |= (key_state & REPEAT_MASK);
+        }
+        if (timer > 0)
+        {
+                timer --;
+        }
+        if (abo_timer > 0)
+        {
+                abo_timer --;
+        }
+}
+//*****************************************************************************
+//
+void TIMER0_Init (void)
+{
+        timer = 0;
+#if defined (__AVR_ATmega32__)
+        TCCR0 = (1 << CS02) | (1 << CS00) | (1 << WGM01);               // Prescaler 1024
+        OCR0 = (F_CPU / (100L * 1024L)) ;
+        TIMSK |= (1 << OCIE0);  // enable interrupt for OCR
+#else
+        TCCR0A = (1 << WGM01);
+        TCCR0B = (1 << CS02) | (1 << CS00);
+        OCR0A = (F_CPU / (100L * 1024L)) ;
+        TIMSK0 |= (1 << OCIE0A);        // enable interrupt for OCR
+#endif
+}
+//*****************************************************************************
+//
+uint8_t get_key_press (uint8_t key_mask)
+{
+        uint8_t sreg = SREG;
+        // disable all interrupts
+        cli();
+  key_mask &= key_press;        // read key(s)
+  key_press ^= key_mask;        // clear key(s)
+        SREG = sreg;    // restore status register
+  return key_mask;
+}
+//*****************************************************************************
+//
+uint8_t get_key_rpt (uint8_t key_mask)
+{
+        uint8_t sreg = SREG;
+        // disable all interrupts
+        cli();
+  key_mask &= key_rpt;  // read key(s)
+  key_rpt ^= key_mask;  // clear key(s)
+        SREG = sreg;    // restore status register
+  return key_mask;
+}
+//*****************************************************************************
+//
+uint8_t get_key_short (uint8_t key_mask)
+{
+        uint8_t ret;
+        uint8_t sreg = SREG;
+        // disable all interrupts
+        cli();
+  ret = get_key_press (~key_state & key_mask);
+        SREG = sreg;    // restore status register
+  return ret;
+}
+//*****************************************************************************
+//
+uint8_t get_key_long (uint8_t key_mask)
+{
+  return get_key_press (get_key_rpt (key_mask));
+}
+//*****************************************************************************
+//
+uint8_t get_key_long2 (uint8_t key_mask)
+{
+  return get_key_press (get_key_rpt (key_press^key_mask));
+}
+//*****************************************************************************
+//
+uint8_t get_key_long_rpt (uint8_t key_mask)
+{
+  return get_key_rpt (~key_press^key_mask);
+}

 /Transportables_Koptertool/trunk/timer.h
 ,0 → 1,50
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   based on the key handling by Peter Dannegger                            *
+ *     see www.mikrocontroller.net                                           *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _TIMER_H
+#define _TIMER_H
+#define KEY_PIN                 PINA
+#define KEY_ENTER               PA7
+#define KEY_ESC                 PA6
+#define KEY_PLUS                PA5
+#define KEY_MINUS               PA4
+#define KEY_ALL                 ((1 << KEY_PLUS) | (1 << KEY_MINUS) | (1 << KEY_ENTER) | (1 << KEY_ESC))
+#define REPEAT_MASK     ((1 << KEY_PLUS) | (1 << KEY_MINUS) | (1 << KEY_ENTER) | (1 << KEY_ESC))        // repeat: MODE
+#define REPEAT_START    50      // after 500ms
+#define REPEAT_NEXT             10      // every 100ms
+#define ABO_TIMEOUT 300 // 3 sec
+extern volatile uint16_t timer;
+extern volatile uint16_t abo_timer;
+void TIMER0_Init (void);
+uint8_t get_key_press (uint8_t key_mask);
+uint8_t get_key_rpt (uint8_t key_mask);
+uint8_t get_key_short (uint8_t key_mask);
+uint8_t get_key_long (uint8_t key_mask);
+uint8_t get_key_long2 (uint8_t key_mask);
+uint8_t get_key_long_rpt (uint8_t key_mask);
+#endif

 /Transportables_Koptertool/trunk/usart.c
 ,0 → 1,515
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   taken some ideas from the C-OSD code from CaScAdE                       *
+ *   the MK communication routines are taken from the MK source              *
+ *    (killagreg version)                                                    *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#include <avr/io.h>
+#include <avr/interrupt.h>
+#include <avr/pgmspace.h>
+#include <avr/wdt.h>
+#include <util/delay.h>
+#include <stdarg.h>
+#include "main.h"
+#include "usart.h"
+#include "lcd.h"
+uint8_t buffer[30];
+volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
+volatile uint8_t txd_complete = TRUE;
+volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
+volatile uint8_t rxd_buffer_locked = FALSE;
+volatile uint8_t ReceivedBytes = 0;
+volatile uint8_t *pRxData = 0;
+volatile uint8_t RxDataLen = 0;
+volatile uint16_t stat_crc_error = 0;
+volatile uint16_t stat_overflow_error = 0;
+#ifdef DEBUG_UART
+//*****************************************************************************
+// USART1 transmitter ISR
+ISR (USART1_TXC_vect)
+{
+        static uint16_t ptr_txd_buffer = 0;
+        uint8_t tmp_tx;
+        if(!txd_complete) // transmission not completed
+        {
+                ptr_txd_buffer++;                    // [0] was already sent
+                tmp_tx = txd_buffer[ptr_txd_buffer];
+                // if terminating character or end of txd buffer was reached
+                if((tmp_tx == '\r') || (ptr_txd_buffer == TXD_BUFFER_LEN))
+                {
+                        ptr_txd_buffer = 0;             // reset txd pointer
+                        txd_complete = TRUE;    // stop transmission
+                }
+                UDR1 = tmp_tx; // send current byte will trigger this ISR again
+        }
+        // transmission completed
+        else ptr_txd_buffer = 0;
+}
+//*****************************************************************************
+//
+void USART1_Init (void)
+{
+        // set clock divider
+#undef BAUD
+#define BAUD USART_BAUD
+#include <util/setbaud.h>
+        UBRR1H = UBRRH_VALUE;
+        UBRR1L = UBRRL_VALUE;
+#if USE_2X
+        UCSR1A |= (1 << U2X1);  // enable double speed operation
+#else
+        UCSR1A &= ~(1 << U2X1); // disable double speed operation
+#endif
+        // set 8N1
+        UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
+        UCSR1B &= ~(1 << UCSZ12);
+        // flush receive buffer
+        while ( UCSR1A & (1 << RXC1) ) UDR1;
+        //      UCSR1B |= (1 << RXEN1) | (1 << TXEN1);
+        //      UCSR1B |= (1 << RXCIE1) | (1 << TXCIE1);
+        UCSR1B |= (1 << RXEN1) | (1 << TXEN1);
+        UCSR1B |= (1 << TXCIE1);
+}
+void debug ()
+{
+        sprintf (txd_buffer, "test\r");
+        txd_complete = FALSE;
+        UDR1 = txd_buffer[0];
+}
+#endif
+#ifdef USART_INT
+//*****************************************************************************
+// USART0 transmitter ISR
+ISR (USART_TXC_vect)
+{
+        static uint16_t ptr_txd_buffer = 0;
+        uint8_t tmp_tx;
+        if(!txd_complete) // transmission not completed
+        {
+                ptr_txd_buffer++;                    // [0] was already sent
+                tmp_tx = txd_buffer[ptr_txd_buffer];
+                // if terminating character or end of txd buffer was reached
+                if((tmp_tx == '\r') || (ptr_txd_buffer == TXD_BUFFER_LEN))
+                {
+                        ptr_txd_buffer = 0;             // reset txd pointer
+                        txd_complete = TRUE;    // stop transmission
+                }
+                UDR = tmp_tx; // send current byte will trigger this ISR again
+        }
+        // transmission completed
+        else ptr_txd_buffer = 0;
+}
+#endif
+//*****************************************************************************
+//
+ISR (USART_RXC_vect)
+{
+        static uint16_t crc;
+        static uint8_t ptr_rxd_buffer = 0;
+        uint8_t crc1, crc2;
+        uint8_t c;
+        c = UDR;  // catch the received byte
+        if (rxd_buffer_locked)
+        {
+                return; // if rxd buffer is locked immediately return
+        }
+        // the rxd buffer is unlocked
+        if ((ptr_rxd_buffer == 0) && (c == '#')) // if rxd buffer is empty and syncronisation character is received
+        {
+                LED6_OFF;
+                rxd_buffer[ptr_rxd_buffer++] = c; // copy 1st byte to buffer
+                crc = c; // init crc
+        }
+        else if (ptr_rxd_buffer < RXD_BUFFER_LEN) // collect incomming bytes
+        {
+                if(c != '\r') // no termination character
+                {
+                        rxd_buffer[ptr_rxd_buffer++] = c; // copy byte to rxd buffer
+                        crc += c; // update crc
+                }
+                else // termination character was received
+                {
+                        // the last 2 bytes are no subject for checksum calculation
+                        // they are the checksum itself
+                        crc -= rxd_buffer[ptr_rxd_buffer-2];
+                        crc -= rxd_buffer[ptr_rxd_buffer-1];
+                        // calculate checksum from transmitted data
+                        crc %= 4096;
+                        crc1 = '=' + crc / 64;
+                        crc2 = '=' + crc % 64;
+                        // compare checksum to transmitted checksum bytes
+                        if((crc1 == rxd_buffer[ptr_rxd_buffer-2]) && (crc2 == rxd_buffer[ptr_rxd_buffer-1]))
+                        {   // checksum valid
+                                rxd_buffer[ptr_rxd_buffer] = '\r'; // set termination character
+                                ReceivedBytes = ptr_rxd_buffer + 1;// store number of received bytes
+                                if (mode == rxd_buffer[2])
+                                {
+                                        rxd_buffer_locked = TRUE;          // lock the rxd buffer
+                                        LED6_ON;
+                                        // if 2nd byte is an 'R' enable watchdog that will result in an reset
+                                        if(rxd_buffer[2] == 'R') {wdt_enable(WDTO_250MS);} // Reset-Commando
+                                }
+                        }
+                        else
+                        {       // checksum invalid
+                                stat_crc_error++;
+                                rxd_buffer_locked = FALSE; // unlock rxd buffer
+                                //LED5_TOGGLE;
+                                //lcd_putc(0, 6, rxd_buffer[2], 0);
+                        }
+                        ptr_rxd_buffer = 0; // reset rxd buffer pointer
+                }
+        }
+        else // rxd buffer overrun
+        {
+                //LED4_TOGGLE;
+                stat_overflow_error++;
+                ptr_rxd_buffer = 0; // reset rxd buffer
+                rxd_buffer_locked = FALSE; // unlock rxd buffer
+        }
+}
+//*****************************************************************************
+//
+void USART_Init (void)
+{
+        // set clock divider
+        #undef BAUD
+        #define BAUD USART_BAUD
+        #include <util/setbaud.h>
+        UBRRH = UBRRH_VALUE;
+        UBRRL = UBRRL_VALUE;
+#if USE_2X
+        UCSRA |= (1 << U2X);    // enable double speed operation
+#else
+        UCSRA &= ~(1 << U2X);   // disable double speed operation
+#endif
+        // set 8N1
+#if defined (__AVR_ATmega8__) || defined (__AVR_ATmega32__)
+        UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);
+#else
+        UCSRC = (1 << UCSZ1) | (1 << UCSZ0);
+#endif
+        UCSRB &= ~(1 << UCSZ2);
+        // flush receive buffer
+        while ( UCSRA & (1 << RXC) ) UDR;
+        UCSRB |= (1 << RXEN) | (1 << TXEN);
+#ifdef USART_INT
+        UCSRB |= (1 << RXCIE) | (1 << TXCIE);
+#else
+        UCSRB |= (1 << RXCIE);
+#endif
+}
+//*****************************************************************************
+// disable the txd pin of usart
+void USART_DisableTXD (void)
+{
+#ifdef USART_INT
+        UCSRB &= ~(1 << TXCIE);         // disable TX-Interrupt
+#endif
+        UCSRB &= ~(1 << TXEN);          // disable TX in USART
+        DDRB  &= ~(1 << DDB3);          // set TXD pin as input
+        PORTB &= ~(1 << PORTB3);        // disable pullup on TXD pin
+}
+//*****************************************************************************
+// enable the txd pin of usart
+void USART_EnableTXD (void)
+{
+        DDRB  |=  (1 << DDB3);          // set TXD pin as output
+        PORTB &= ~(1 << PORTB3);        // disable pullup on TXD pin
+        UCSRB |=  (1 << TXEN);          // enable TX in USART
+#ifdef USART_INT
+        UCSRB |=  (1 << TXCIE);         // enable TX-Interrupt
+#endif
+}
+//*****************************************************************************
+// short script to directly send a request thorugh usart including en- and disabling it
+// where <address> is the address of the receipient, <label> is which data set to request
+// and <ms> represents the milliseconds delay between data
+void USART_request_mk_data (uint8_t cmd, uint8_t addr, uint8_t ms)
+{
+        USART_EnableTXD ();     // re-enable TXD pin
+        unsigned char mstenth = ms/10;
+        SendOutData(cmd, addr, 1, &mstenth, 1);
+        // wait until command transmitted
+        while (txd_complete == FALSE);
+        USART_DisableTXD ();    // disable TXD pin again
+}
+//*****************************************************************************
+//
+void USART_putc (char c)
+{
+#ifdef USART_INT
+#else
+        loop_until_bit_is_set(UCSRA, UDRE);
+        UDR = c;
+#endif
+}
+//*****************************************************************************
+//
+void USART_puts (char *s)
+{
+#ifdef USART_INT
+#else
+        while (*s)
+        {
+                USART_putc (*s);
+                s++;
+        }
+#endif
+}
+//*****************************************************************************
+//
+void USART_puts_p (const char *s)
+{
+#ifdef USART_INT
+#else
+        while (pgm_read_byte(s))
+        {
+                USART_putc (pgm_read_byte(s));
+                s++;
+        }
+#endif
+}
+//*****************************************************************************
+//
+void SendOutData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...) // uint8_t *pdata, uint8_t len, ...
+{
+        va_list ap;
+        uint16_t pt = 0;
+        uint8_t a,b,c;
+        uint8_t ptr = 0;
+        uint16_t tmpCRC = 0;
+        uint8_t *pdata = 0;
+        int len = 0;
+        txd_buffer[pt++] = '#';                                 // Start character
+        txd_buffer[pt++] = 'a' + addr;  // Address (a=0; b=1,...)
+        txd_buffer[pt++] = cmd;                                 // Command
+        va_start(ap, numofbuffers);
+        if(numofbuffers)
+        {
+                pdata = va_arg (ap, uint8_t*);
+                len = va_arg (ap, int);
+                ptr = 0;
+                numofbuffers--;
+        }
+        while(len)
+        {
+                if(len)
+                {
+                        a = pdata[ptr++];
+                        len--;
+                        if((!len) && numofbuffers)
+                        {
+                                pdata = va_arg(ap, uint8_t*);
+                                len = va_arg(ap, int);
+                                ptr = 0;
+                                numofbuffers--;
+                        }
+                }
+                else a = 0;
+                if(len)
+                {
+                        b = pdata[ptr++];
+                        len--;
+                        if((!len) && numofbuffers)
+                        {
+                                pdata = va_arg(ap, uint8_t*);
+                                len = va_arg(ap, int);
+                                ptr = 0;
+                                numofbuffers--;
+                        }
+                }
+                else b = 0;
+                if(len)
+                {
+                        c = pdata[ptr++];
+                        len--;
+                        if((!len) && numofbuffers)
+                        {
+                                pdata = va_arg(ap, uint8_t*);
+                                len = va_arg(ap, int);
+                                ptr = 0;
+                                numofbuffers--;
+                        }
+                }
+                else c = 0;
+                txd_buffer[pt++] = '=' + (a >> 2);
+                txd_buffer[pt++] = '=' + (((a & 0x03) << 4) | ((b & 0xf0) >> 4));
+                txd_buffer[pt++] = '=' + (((b & 0x0f) << 2) | ((c & 0xc0) >> 6));
+                txd_buffer[pt++] = '=' + ( c & 0x3f);
+        }
+        va_end(ap);
+        for(a = 0; a < pt; a++)
+        {
+                tmpCRC += txd_buffer[a];
+        }
+        tmpCRC %= 4096;
+        txd_buffer[pt++] = '=' + tmpCRC / 64;
+        txd_buffer[pt++] = '=' + tmpCRC % 64;
+        txd_buffer[pt++] = '\r';
+        txd_complete = FALSE;
+#ifdef USART_INT
+        UDR = txd_buffer[0]; // initiates the transmittion (continued in the TXD ISR)
+#else
+        for(a = 0; a < pt; a++)
+        {
+                loop_until_bit_is_set(UCSRA, UDRE);
+                UDR = txd_buffer[a];
+        }
+        txd_complete = TRUE;
+#endif
+}
+//*****************************************************************************
+//
+void Decode64 (void)
+{
+        uint8_t a,b,c,d;
+        uint8_t ptrIn = 3;
+        uint8_t ptrOut = 3;
+        uint8_t len = ReceivedBytes - 6;
+        while (len)
+        {
+                a = rxd_buffer[ptrIn++] - '=';
+                b = rxd_buffer[ptrIn++] - '=';
+                c = rxd_buffer[ptrIn++] - '=';
+                d = rxd_buffer[ptrIn++] - '=';
+                //if(ptrIn > ReceivedBytes - 3) break;
+                if (len--)
+                        rxd_buffer[ptrOut++] = (a << 2) | (b >> 4);
+                else
+                        break;
+                if (len--)
+                        rxd_buffer[ptrOut++] = ((b & 0x0f) << 4) | (c >> 2);
+                else
+                        break;
+                if (len--)
+                        rxd_buffer[ptrOut++] = ((c & 0x03) << 6) | d;
+                else
+                        break;
+        }
+        pRxData = &rxd_buffer[3];
+        RxDataLen = ptrOut - 3;
+}
+//*****************************************************************************
+//
+void SwitchToNC (void)
+{
+        // switch to NC
+        USART_putc (0x1b);
+        USART_putc (0x1b);
+        USART_putc (0x55);
+        USART_putc (0xaa);
+        USART_putc (0x00);
+        current_hardware = NC;
+        _delay_ms (50);
+}
+//*****************************************************************************
+//
+void SwitchToFC (void)
+{
+        uint8_t cmd;
+        if (current_hardware == NC)
+        {
+                // switch to FC
+                cmd = 0x00;     // 0 = FC, 1 = MK3MAG, 2 = MKGPS
+                SendOutData('u', ADDRESS_NC, 1, &cmd, 1);
+                current_hardware = FC;
+                _delay_ms (50);
+        }
+}
+//*****************************************************************************
+//
+void SwitchToMAG (void)
+{
+        uint8_t cmd;
+        if (current_hardware == NC)
+        {
+                // switch to MK3MAG
+                cmd = 0x01;     // 0 = FC, 1 = MK3MAG, 2 = MKGPS
+                SendOutData('u', ADDRESS_NC, 1, &cmd, 1);
+                current_hardware = MK3MAG;
+                _delay_ms (50);
+        }
+}
+//*****************************************************************************
+//
+void SwitchToGPS (void)
+{
+        uint8_t cmd;
+        if (current_hardware == NC)
+        {
+                // switch to MKGPS
+                cmd = 0x02;     // 0 = FC, 1 = MK3MAG, 2 = MKGPS
+                SendOutData('u', ADDRESS_NC, 1, &cmd, 1);
+                current_hardware = MKGPS;
+                _delay_ms (50);
+        }
+}

 /Transportables_Koptertool/trunk/usart.h
 ,0 → 1,127
+/*****************************************************************************
+ *   Copyright (C) 2009 Peter "woggle" Mack, mac@denich.net                  *
+ *   taken some ideas from the C-OSD code from CaScAdE                       *
+ *   the MK communication routines are taken from the MK source              *
+ *    (killagreg version)                                                    *
+ *                                                                           *
+ *   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 2 of the License.          *
+ *                                                                           *
+ *   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, write to the                           *
+ *   Free Software Foundation, Inc.,                                         *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.               *
+ *                                                                           *
+ *****************************************************************************/
+#ifndef _USART_H
+#define _USART_H
+//*****************************************************************************
+//
+#ifndef FALSE
+#define FALSE   0
+#endif
+#ifndef TRUE
+#define TRUE    1
+#endif
+// addresses
+#define ADDRESS_ANY     0
+#define ADDRESS_FC      1
+#define ADDRESS_NC      2
+#define ADDRESS_MAG     3
+// must be at least 4('#'+Addr+'CmdID'+'\r')+ (80 * 4)/3 = 111 bytes
+#define TXD_BUFFER_LEN  60
+#define RXD_BUFFER_LEN  180
+// Baud rate of the USART
+#define USART_BAUD 57600
+//*****************************************************************************
+//
+extern uint8_t buffer[30];
+extern volatile uint8_t txd_buffer[TXD_BUFFER_LEN];
+extern volatile uint8_t txd_complete;
+extern volatile uint8_t rxd_buffer[RXD_BUFFER_LEN];
+extern volatile uint8_t rxd_buffer_locked;
+extern volatile uint8_t ReceivedBytes;
+extern volatile uint8_t *pRxData;
+extern volatile uint8_t RxDataLen;
+extern volatile uint16_t stat_crc_error;
+extern volatile uint16_t stat_overflow_error;
+//*****************************************************************************
+//
+void USART_Init (void);
+void USART_DisableTXD (void);
+void USART_EnableTXD (void);
+void USART_request_mk_data (uint8_t cmd, uint8_t addr, uint8_t ms);
+void USART_putc (char c);
+void USART_puts (char *s);
+void USART_puts_p (const char *s);
+void SendOutData (uint8_t cmd, uint8_t addr, uint8_t numofbuffers, ...); // uint8_t *pdata, uint8_t len, ...
+//void SendOutData(uint8_t cmd, uint8_t addr, uint8_t numofbuffers, uint8_t *pdata, uint8_t len); // uint8_t *pdata, uint8_t len, ...
+void Decode64 (void);
+void SwitchToNC (void);
+void SwitchToFC (void);
+void SwitchToMAG (void);
+void SwitchToGPS (void);
+//*****************************************************************************
+//Anpassen der seriellen Schnittstellen Register
+#if defined (__AVR_ATmega644__) || defined (__AVR_ATmega644P__) || defined (__AVR_ATmega168__)
+#define USART_RXC_vect USART0_RX_vect
+//-----------------------
+#define UCSRA           UCSR0A
+#define UCSRB           UCSR0B
+#define UCSRC           UCSR0C
+#define UDR                     UDR0
+#define UBRRL           UBRR0L
+#define UBRRH           UBRR0H
+// UCSRA
+#define RXC                     RXC0
+#define TXC                     TXC0
+#define UDRE            UDRE0
+#define FE                      FE0
+#define UPE                     UPE0
+#define U2X                     U2X0
+#define MPCM            MPCM0
+// UCSRB
+#define RXCIE           RXCIE0
+#define TXCIE           TXCIE0
+#define UDRIE           UDRIE0
+#define TXEN            TXEN0
+#define RXEN            RXEN0
+#define UCSZ2           UCSZ02
+#define RXB8            RXB80
+#define TXB8            TXB80
+// UCSRC
+#define UMSEL1  UMSEL01
+#define UMSEL0  UMSEL00
+#define UPM1            UPM01
+#define UPM0            UPM00
+#define USBS            USBS0
+#define UCSZ1           UCSZ01
+#define UCSZ0           UCSZ00
+#define UCPOL           UCPOL0
+//-----------------------
+#endif
+#endif

Subversion Repositories Projects

Compare Revisions

Ignore whitespace Rev 729 → Rev 730