feat: 增加vl53l0x驱动

.clang-format

@@ -7,8 +7,8 @@ Language: Cpp
 ###################################
 
 UseTab: Never
-IndentWidth: 4
+IndentWidth: 2
-TabWidth: 4
+TabWidth: 2
 ColumnLimit: 0
 AccessModifierOffset: -4
 NamespaceIndentation: All

.eide/eide.json

@@ -7,7 +7,8 @@
     "libraries/cmsis",
     "libraries/drivers",
     "project",
-    "app"
+    "app",
+    "3rd-part"
   ],
   "virtualFolder": {
     "name": "<virtual_root>",
@@ -67,7 +68,11 @@
           "libraries/cmsis/cm4/core_support",
           "libraries/cmsis/cm4/device_support",
           "project/inc",
-          "libraries/drivers/inc"
+          "libraries/drivers/inc",
+          "3rd-part/dwt_delay",
+          "3rd-part/lwprintf",
+          "3rd-part/Simple_VL53L0X",
+          "3rd-part/zf_vl53l0"
         ],
         "libList": [],
         "sourceDirList": [],

3rd-part/Simple_VL53L0X/LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

3rd-part/Simple_VL53L0X/ST_I2C.c

@@ -0,0 +1,320 @@
+#include "ST_I2C.h"
+
+
+#define TRUE 1
+#define FALSE 0
+
+static uint8_t ST_IIC_Start(void);				
+static void ST_IIC_Stop(void);	  		
+static void ST_IIC_Send_Byte(uint8_t txd);	
+static uint8_t ST_IIC_Read_Byte(void);
+static uint8_t ST_IIC_Wait_Ack(void); 	
+static void ST_IIC_Ack(void);				
+static void ST_IIC_NAck(void);		
+
+
+
+
+static void IIC_delay(void)
+{
+   volatile uint8_t i=5;//第一次使用时需要增加到1000
+   while(i)
+   {
+     i--;
+   }
+}
+
+
+/**************************实现函数********************************************
+*函数原型:		void ST_IIC_Start(void)
+*功　　能:		产生IIC起始信号
+*******************************************************************************/
+static uint8_t ST_IIC_Start(void)
+{
+	SDA_H;
+	SCL_H;
+	IIC_delay();
+	if(!SDA_read)
+		return FALSE;	
+	SDA_L;
+	IIC_delay();
+	if(SDA_read)
+		return FALSE;	
+	SDA_L;
+	IIC_delay();
+	return TRUE;
+}
+
+/**************************实现函数********************************************
+*函数原型:		void ST_IIC_Stop(void)
+*功　　能:	    //产生IIC停止信号
+*******************************************************************************/
+static void ST_IIC_Stop(void)
+{
+	SCL_L;
+	IIC_delay();
+	SDA_L;
+	IIC_delay();
+	SCL_H;
+	IIC_delay();
+	SDA_H;
+	IIC_delay();
+}
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t ST_IIC_Wait_Ack(void)
+*功　　能:	    等待应答信号到来
+//返回值：1，接收应答失败
+//        0，接收应答成功
+*******************************************************************************/
+static uint8_t ST_IIC_Wait_Ack(void) 	
+{
+	SCL_L;
+	IIC_delay();
+	SDA_H;
+	IIC_delay();
+	SCL_H;
+	IIC_delay();
+	if(SDA_read)
+	{
+    SCL_L;
+	  IIC_delay();
+      return FALSE;
+	}
+	SCL_L;
+	IIC_delay();
+	return TRUE;
+}
+
+/**************************实现函数********************************************
+*函数原型:		void ST_IIC_Ack(void)
+*功　　能:	    产生ACK应答
+*******************************************************************************/
+static void ST_IIC_Ack(void)
+{
+	SCL_L;
+	IIC_delay();
+	SDA_L;
+	IIC_delay();
+	SCL_H;
+	IIC_delay();
+	SCL_L;
+	IIC_delay();
+}
+
+/**************************实现函数********************************************
+*函数原型:		void ST_IIC_NAck(void)
+*功　　能:	    产生NACK应答
+*******************************************************************************/
+static void ST_IIC_NAck(void)
+{
+	SCL_L;
+	IIC_delay();
+	SDA_H;
+	IIC_delay();
+	SCL_H;
+	IIC_delay();
+	SCL_L;
+	IIC_delay();
+}
+
+/**************************实现函数********************************************
+*函数原型:		void ST_IIC_Send_Byte(uint8_t txd)
+*功　　能:	    IIC发送一个字节
+*******************************************************************************/
+static void ST_IIC_Send_Byte(uint8_t SendByte) 
+{
+    uint8_t i=8;
+    while(i--)
+    {
+			SCL_L;
+			IIC_delay();
+			if(SendByte&0x80)
+				SDA_H;
+			else
+				SDA_L;
+			SendByte<<=1;
+			IIC_delay();
+			SCL_H;
+			IIC_delay();
+    }
+    SCL_L;
+}
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t ST_IIC_Read_Byte(unsigned char ack)
+*功　　能:	    //读1串字节，ack=1时，发送ACK，ack=0，发送nACK
+*******************************************************************************/
+static unsigned char ST_IIC_Read_Byte(void)  
+{
+    uint8_t i=8;
+    uint8_t ReceiveByte=0;
+
+    SDA_H;
+    while(i--)
+    {
+			ReceiveByte<<=1;
+			SCL_L;
+			IIC_delay();
+			SCL_H;
+			IIC_delay();
+			if(SDA_read)
+			{
+				ReceiveByte|=0x01;
+			}
+    }
+    SCL_L;
+    return ReceiveByte;
+}
+
+/**************************实现函数********************************************
+*函数原型:		unsigned char IIC_ReadOneByte(unsigned char I2C_Addr,unsigned char addr)
+*功　　能:	    读取指定设备 指定寄存器的一个值
+输入	I2C_Addr  目标设备地址
+		addr	   寄存器地址
+返回   读出来的值
+*******************************************************************************/
+uint8_t IIC_ReadOneByte(uint8_t SlaveAddress,uint8_t REG_Address)
+{
+		if(!ST_IIC_Start())
+			return FALSE;
+    ST_IIC_Send_Byte(SlaveAddress); 
+    if(!ST_IIC_Wait_Ack())
+		{
+			ST_IIC_Stop();
+			return FALSE;
+		}
+    ST_IIC_Send_Byte((uint8_t) REG_Address);   
+    ST_IIC_Wait_Ack();
+    ST_IIC_Start();
+    ST_IIC_Send_Byte(SlaveAddress+1);
+    ST_IIC_Wait_Ack();
+
+		ST_IIC_Read_Byte();
+    ST_IIC_NAck();
+    ST_IIC_Stop();
+    //return TRUE;
+		return 0;
+
+}
+
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t IICreadBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t *data)
+*功　　能:	    读取指定设备 指定寄存器的 length个值
+输入	dev  目标设备地址
+		reg	  寄存器地址
+		length 要读的字节数
+		*data  读出的数据将要存放的指针
+返回   读出来的字节数量
+*******************************************************************************/
+uint8_t ST_IICreadBytes(uint8_t SlaveAddress,uint8_t REG_Address,uint8_t len,uint8_t *data)
+{
+		uint8_t i = 0;
+		if(!ST_IIC_Start())
+			return FALSE;
+    ST_IIC_Send_Byte(SlaveAddress); 
+    if(!ST_IIC_Wait_Ack())
+		{
+			ST_IIC_Stop();
+			return FALSE;
+		}
+    ST_IIC_Send_Byte((uint8_t) REG_Address);   
+    ST_IIC_Wait_Ack();
+    ST_IIC_Start();
+    ST_IIC_Send_Byte(SlaveAddress+1);
+    ST_IIC_Wait_Ack();
+
+		for(i = 0;i<len;i++)
+		{
+			if(i != (len -1))
+			{
+				data[i]= ST_IIC_Read_Byte();
+				ST_IIC_Ack();
+			}
+			else
+			{
+				data[i]= ST_IIC_Read_Byte();
+				ST_IIC_NAck();
+			}
+		}
+		ST_IIC_Stop();
+    //return TRUE;
+		return 0;
+}
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t IICwriteBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t* data)
+*功　　能:	    将多个字节写入指定设备 指定寄存器
+输入	dev  目标设备地址
+		reg	  寄存器地址
+		length 要写的字节数
+		*data  将要写的数据的首地址
+返回   返回是否成功
+*******************************************************************************/
+uint8_t ST_IICwriteBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t* data)
+{
+
+ 	uint8_t count = 0;
+	ST_IIC_Start();
+	ST_IIC_Send_Byte(dev);	   
+	ST_IIC_Wait_Ack();
+	ST_IIC_Send_Byte(reg);   
+    ST_IIC_Wait_Ack();
+	for(count=0;count<length;count++)
+	{
+		ST_IIC_Send_Byte(data[count]);
+		ST_IIC_Wait_Ack();
+	 }
+	ST_IIC_Stop();
+
+    return 0; //status == 0;
+}
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t IICreadByte(uint8_t dev, uint8_t reg, uint8_t *data)
+*功　　能:	    读取指定设备 指定寄存器的一个值
+输入	dev  目标设备地址
+		reg	   寄存器地址
+		*data  读出的数据将要存放的地址
+返回   1
+*******************************************************************************/
+uint8_t ST_IICreadByte(uint8_t dev, uint8_t reg, uint8_t *data)
+{
+	*data=IIC_ReadOneByte(dev, reg);
+    return 0;
+}
+
+/**************************实现函数********************************************
+*函数原型:		unsigned char IICwriteByte(unsigned char dev, unsigned char reg, unsigned char data)
+*功　　能:	    写入指定设备 指定寄存器一个字节
+输入	dev  目标设备地址
+		reg	   寄存器地址
+		data  将要写入的字节
+返回   1
+*******************************************************************************/
+uint8_t ST_IICwriteByte(uint8_t dev, uint8_t reg, uint8_t data)
+{
+    return ST_IICwriteBytes(dev, reg, 1, &data);
+}
+
+
+/**************************实现函数********************************************
+*函数原型:		uint8_t IICwriteBit(uint8_t dev, uint8_t reg, uint8_t bitNum, uint8_t data)
+*功　　能:	    读 修改 写 指定设备 指定寄存器一个字节 中的1个位
+输入	dev  目标设备地址
+		reg	   寄存器地址
+		bitNum  要修改目标字节的bitNum位
+		data  为0 时，目标位将被清0 否则将被置位
+返回   成功 为1
+ 		失败为0
+*******************************************************************************/
+uint8_t ST_IICwriteBit(uint8_t dev, uint8_t reg, uint8_t bitNum, uint8_t data)
+{
+    uint8_t b;
+    ST_IICreadByte(dev, reg, &b);
+    b = (data != 0) ? (b | (1 << bitNum)) : (b & ~(1 << bitNum));
+    return ST_IICwriteByte(dev, reg, b);
+}
+
+//------------------End of File----------------------------

3rd-part/Simple_VL53L0X/ST_I2C.h

@@ -0,0 +1,47 @@
+#ifndef __IOI2C_H
+#define __IOI2C_H
+// #include "stm32f4xx_hal.h"
+#include "at32f415.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+// IO 口操作宏定义
+#define BITBAND(addr, bitnum)  ((addr & 0xF0000000) + 0x2000000 + ((addr & 0xFFFFF) << 5) + (bitnum << 2))
+#define MEM_ADDR(addr)         *((volatile unsigned long *)(addr))
+#define BIT_ADDR(addr, bitnum) MEM_ADDR(BITBAND(addr, bitnum))
+
+/**
+ * @name 需要自行更改的IIC_GPIO定义
+ * @{
+ */
+// #define SCL_H         HAL_GPIO_WritePin(IIC_SCL_GPIO_Port,IIC_SCL_Pin,GPIO_PIN_SET)
+// #define SCL_L         HAL_GPIO_WritePin(IIC_SCL_GPIO_Port,IIC_SCL_Pin,GPIO_PIN_RESET)
+
+// #define SDA_H         HAL_GPIO_WritePin(IIC_SDA_GPIO_Port,IIC_SDA_Pin,GPIO_PIN_SET)
+// #define SDA_L         HAL_GPIO_WritePin(IIC_SDA_GPIO_Port,IIC_SDA_Pin,GPIO_PIN_RESET)
+
+// #define SCL_read      HAL_GPIO_ReadPin(IIC_SCL_GPIO_Port,IIC_SCL_Pin)
+// #define SDA_read      HAL_GPIO_ReadPin(IIC_SDA_GPIO_Port,IIC_SDA_Pin)
+
+#define SCL_H    gpio_bits_write(GPIOB, GPIO_PINS_6, SET)
+#define SCL_L    gpio_bits_write(GPIOB, GPIO_PINS_6, RESET)
+
+#define SDA_H    gpio_bits_write(GPIOB, GPIO_PINS_7, SET)
+#define SDA_L    gpio_bits_write(GPIOB, GPIO_PINS_7, RESET)
+
+#define SCL_read gpio_input_data_bit_read(GPIOB, GPIO_PINS_6)
+#define SDA_read gpio_input_data_bit_read(GPIOB, GPIO_PINS_7)
+/** @} */
+extern void ST_IIC_Init(void); //<初始化 IIC 的 IO 口
+
+extern unsigned char ST_IIC_ReadOneByte(unsigned char I2C_Addr, unsigned char addr);
+extern unsigned char ST_IICwriteByte(unsigned char dev, unsigned char reg, unsigned char data);
+extern uint8_t ST_IICwriteBytes(uint8_t dev, uint8_t reg, uint8_t length, uint8_t *data);
+extern uint8_t ST_IICwriteBit(uint8_t dev, uint8_t reg, uint8_t bitNum, uint8_t data);
+extern uint8_t ST_IICreadBytes(uint8_t SlaveAddress, uint8_t REG_Address, uint8_t len, uint8_t *data);
+#ifdef __cplusplus
+}
+#endif
+#endif
+
+//------------------End of File----------------------------

3rd-part/Simple_VL53L0X/VL53l0x_i2c_dev.c

@@ -0,0 +1,120 @@
+/**
+ * @brief        移植用的适配 STM32 的 HAL 库的驱动文件 非官方 自己适配的
+ * @author      WMD
+ * @date     2018 年 4 月 22 日 21:20:32
+ * @version
+ * @par Copyright (c):
+ *       WMD
+ * @par 日志
+ */
+#include "ST_I2C.h"
+#include "vl53l0x_api.h"
+
+#include "by_debug.h"
+// #include "cmsis_os.h"
+
+/**
+ * @name 自定义移植接口函数
+ * @{
+ */
+VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count)
+{
+  return ST_IICwriteBytes(Dev->I2cDevAddr, index, count, pdata);
+}
+VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count)
+{
+  return ST_IICreadBytes(Dev->I2cDevAddr, index, count, pdata);
+}
+VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data)
+{
+  return ST_IICwriteByte(Dev->I2cDevAddr, index, data);
+}
+VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data)
+{
+  return VL53L0X_ReadMulti(Dev, index, data, 1);
+}
+/// 注意以下这些函数有可能会导致大小端不对
+VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data)
+{
+  uint8_t tmp[2] = {((uint16_t)(data & 0xff00) >> 8), ((uint16_t)data & 0x00ff)};
+  return ST_IICwriteBytes(Dev->I2cDevAddr, index, 2, tmp);
+}
+VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data)
+{
+  uint8_t tmp[4] = {((data & 0xff000000) >> 24), ((data & 0x00ff0000) >> 16), ((data & 0x0000ff00) >> 8), ((data & 0x000000ff))};
+  return ST_IICwriteBytes(Dev->I2cDevAddr, index, 4, tmp);
+}
+VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data)
+{
+  uint8_t tmp[2];
+  uint8_t *p = (uint8_t *)data;
+  ST_IICreadBytes(Dev->I2cDevAddr, index, 2, tmp);
+  p[0] = tmp[1];
+  p[1] = tmp[0];
+  return 0;
+}
+VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data)
+{
+  uint8_t tmp[4];
+  uint8_t *p = (uint8_t *)data;
+  ST_IICreadBytes(Dev->I2cDevAddr, index, 4, tmp);
+  p[0] = tmp[3];
+  p[1] = tmp[2];
+  p[2] = tmp[1];
+  p[3] = tmp[0];
+  return 0;
+}
+
+VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index, uint8_t AndData, uint8_t OrData)
+{
+  uint8_t tmp;
+  ST_IICreadBytes(Dev->I2cDevAddr, index, 1, &tmp);
+  tmp = (tmp & AndData) | OrData;
+  return ST_IICwriteByte(Dev->I2cDevAddr, index, tmp);
+}
+//! 该函数是等待用函数 要改成对应环境的 Delay
+VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev)
+{
+  // osDelay(5);
+  delay_ms(5);
+
+  return 0;
+}
+/** @} */
+// 接下来是要引出的简化 API 函数
+//! 激光传感器的结构体
+static VL53L0X_Dev_t TestDev_s;
+static VL53L0X_DEV TestDev = &TestDev_s;
+static VL53L0X_RangingMeasurementData_t TestData_s;
+static VL53L0X_RangingMeasurementData_t *TestData = &TestData_s;
+
+/**
+ * @brief  激光传感器初始化
+ * @param void
+ * @retval  void
+ * @par 日志
+ *
+ */
+void VL53L0X_Init(void)
+{
+  TestDev->I2cDevAddr = 0x52;
+  VL53L0X_SetDeviceAddress(TestDev, 0x52);                               // 设置地址
+  VL53L0X_SetPowerMode(TestDev, VL53L0X_POWERMODE_STANDBY_LEVEL2);       // 设定最不省电模式
+  VL53L0X_SetDeviceMode(TestDev, VL53L0X_DEVICEMODE_CONTINUOUS_RANGING); // 设定连续读取模式
+  VL53L0X_SetInterMeasurementPeriodMilliSeconds(TestDev, 10);            // 设定采样时间
+  VL53L0X_DataInit(TestDev);
+}
+/**
+ * @brief  获得激光传感器的距离
+ * @param void
+ * @retval  uint16_t 距离 (单位 mm)
+ * @note 如果不在任务中使用的话记得修改延时函数
+ * @par 日志
+ *
+ */
+uint16_t VL53L0X_GetValue(void)
+{
+  VL53L0X_PerformSingleMeasurement(TestDev); // 简单测量
+  VL53L0X_GetRangingMeasurementData(TestDev, TestData);
+  return TestData->RangeMilliMeter;
+}

3rd-part/Simple_VL53L0X/readme.md

@@ -0,0 +1,13 @@
+#<23><><EFBFBD><EFBFBD><EFBFBD>ͼ<EFBFBD><CDBC>⴫<EFBFBD><E2B4AB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̿<EFBFBD> By WMD
+<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ж<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>...<2E><>װ<EFBFBD><D7B0>ֻ<EFBFBD><D6BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>:VL53L0X_Init() <20><> VL53L0X_GetValue() <20><><EFBFBD><EFBFBD><EFBFBD>÷<EFBFBD><C3B7><EFBFBD><EFBFBD>ض<EFBFBD>˵
+Ĭ<EFBFBD>ϵij<EFBFBD>ʼ<EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʽΪ:ѭ<><D1AD><EFBFBD><EFBFBD>ȡ <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ĭ<EFBFBD>ϵ<EFBFBD>ַ
+ֱ<EFBFBD><EFBFBD>GetValue<EFBFBD><EFBFBD><EFBFBD>Ǿ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+
+
+##<23><>ֲʱ<D6B2><CAB1>Ҫע<D2AA><D7A2><EFBFBD>ĵط<C4B5>
+> * <20>ڶ<EFBFBD>ȡ<EFBFBD><C8A1><EFBFBD>ݵ<EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD>Ǵ<EFBFBD><C7B4><EFBFBD><EFBFBD><EFBFBD>ѯ״̬<D7B4><CCAC> <20><><EFBFBD>Ի<EFBFBD><D4BB>õ<EFBFBD>һ<EFBFBD><D2BB><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>VL53L0X_PollingDelay()<29><><EFBFBD><EFBFBD><EFBFBD>滻Ϊ<E6BBBB>Լ<EFBFBD><D4BC><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD> Ĭ<>ϵ<EFBFBD>ΪCMSIS_OS<4F><53>׼<EFBFBD><D7BC><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>
+> * IICʹ<43>õ<EFBFBD><C3B5><EFBFBD>ģ<EFBFBD><C4A3>IIC,<2C><>ST_I2C.h<><68><EFBFBD><EFBFBD><EFBFBD>漰IO<49><4F><EFBFBD><EFBFBD><EFBFBD>ĺ<EFBFBD><C4BA><EFBFBD> <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>滻Ϊ<E6BBBB>Լ<EFBFBD><D4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD>е<EFBFBD>IO<49><4F><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
+> * ʵ<><CAB5><EFBFBD><EFBFBD>ȡһ<C8A1><D2BB><EFBFBD><EFBFBD>Ҫ<EFBFBD><D2AA>ʱ<EFBFBD><CAB1><EFBFBD><EFBFBD>30-60ms
+
+##<23><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŭ<EFBFBD><C5AC><EFBFBD><EFBFBD>ѧϰ<D1A7><CFB0> <20><><EFBFBD>Ҳ<EFBFBD>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̫<EFBFBD><CCAB>...
+##[My Github](https://github.com/wmdscjhdpy)

3rd-part/Simple_VL53L0X/vl53l0x_api_calibration.h

@@ -0,0 +1,85 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of STMicroelectronics nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_CALIBRATION_H_
+#define _VL53L0X_API_CALIBRATION_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+VL53L0X_Error VL53L0X_perform_xtalk_calibration(VL53L0X_DEV Dev,
+		FixPoint1616_t XTalkCalDistance,
+		FixPoint1616_t *pXTalkCompensationRateMegaCps);
+
+VL53L0X_Error VL53L0X_perform_offset_calibration(VL53L0X_DEV Dev,
+		FixPoint1616_t CalDistanceMilliMeter,
+		int32_t *pOffsetMicroMeter);
+
+VL53L0X_Error VL53L0X_set_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
+		int32_t OffsetCalibrationDataMicroMeter);
+
+VL53L0X_Error VL53L0X_get_offset_calibration_data_micro_meter(VL53L0X_DEV Dev,
+		int32_t *pOffsetCalibrationDataMicroMeter);
+
+VL53L0X_Error VL53L0X_apply_offset_adjustment(VL53L0X_DEV Dev);
+
+VL53L0X_Error VL53L0X_perform_ref_spad_management(VL53L0X_DEV Dev,
+		uint32_t *refSpadCount, uint8_t *isApertureSpads);
+
+VL53L0X_Error VL53L0X_set_reference_spads(VL53L0X_DEV Dev,
+		uint32_t count, uint8_t isApertureSpads);
+
+VL53L0X_Error VL53L0X_get_reference_spads(VL53L0X_DEV Dev,
+		uint32_t *pSpadCount, uint8_t *pIsApertureSpads);
+
+VL53L0X_Error VL53L0X_perform_phase_calibration(VL53L0X_DEV Dev,
+	uint8_t *pPhaseCal, const uint8_t get_data_enable,
+	const uint8_t restore_config);
+
+VL53L0X_Error VL53L0X_perform_ref_calibration(VL53L0X_DEV Dev,
+	uint8_t *pVhvSettings, uint8_t *pPhaseCal, uint8_t get_data_enable);
+
+VL53L0X_Error VL53L0X_set_ref_calibration(VL53L0X_DEV Dev,
+		uint8_t VhvSettings, uint8_t PhaseCal);
+
+VL53L0X_Error VL53L0X_get_ref_calibration(VL53L0X_DEV Dev,
+		uint8_t *pVhvSettings, uint8_t *pPhaseCal);
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_CALIBRATION_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_api_core.h

@@ -0,0 +1,108 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_CORE_H_
+#define _VL53L0X_API_CORE_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+VL53L0X_Error VL53L0X_reverse_bytes(uint8_t *data, uint32_t size);
+
+VL53L0X_Error VL53L0X_measurement_poll_for_completion(VL53L0X_DEV Dev);
+
+uint8_t VL53L0X_encode_vcsel_period(uint8_t vcsel_period_pclks);
+
+uint8_t VL53L0X_decode_vcsel_period(uint8_t vcsel_period_reg);
+
+uint32_t VL53L0X_isqrt(uint32_t num);
+
+uint32_t VL53L0X_quadrature_sum(uint32_t a, uint32_t b);
+
+VL53L0X_Error VL53L0X_get_info_from_device(VL53L0X_DEV Dev, uint8_t option);
+
+VL53L0X_Error VL53L0X_set_vcsel_pulse_period(VL53L0X_DEV Dev,
+	VL53L0X_VcselPeriod VcselPeriodType, uint8_t VCSELPulsePeriodPCLK);
+
+VL53L0X_Error VL53L0X_get_vcsel_pulse_period(VL53L0X_DEV Dev,
+	VL53L0X_VcselPeriod VcselPeriodType, uint8_t *pVCSELPulsePeriodPCLK);
+
+uint32_t VL53L0X_decode_timeout(uint16_t encoded_timeout);
+
+VL53L0X_Error get_sequence_step_timeout(VL53L0X_DEV Dev,
+			VL53L0X_SequenceStepId SequenceStepId,
+			uint32_t *pTimeOutMicroSecs);
+
+VL53L0X_Error set_sequence_step_timeout(VL53L0X_DEV Dev,
+			VL53L0X_SequenceStepId SequenceStepId,
+			uint32_t TimeOutMicroSecs);
+
+VL53L0X_Error VL53L0X_set_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
+	uint32_t MeasurementTimingBudgetMicroSeconds);
+
+VL53L0X_Error VL53L0X_get_measurement_timing_budget_micro_seconds(VL53L0X_DEV Dev,
+		uint32_t *pMeasurementTimingBudgetMicroSeconds);
+
+VL53L0X_Error VL53L0X_load_tuning_settings(VL53L0X_DEV Dev,
+		uint8_t *pTuningSettingBuffer);
+
+VL53L0X_Error VL53L0X_calc_sigma_estimate(VL53L0X_DEV Dev,
+		VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+		FixPoint1616_t *pSigmaEstimate, uint32_t *pDmax_mm);
+
+VL53L0X_Error VL53L0X_get_total_xtalk_rate(VL53L0X_DEV Dev,
+	VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+	FixPoint1616_t *ptotal_xtalk_rate_mcps);
+
+VL53L0X_Error VL53L0X_get_total_signal_rate(VL53L0X_DEV Dev,
+	VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+	FixPoint1616_t *ptotal_signal_rate_mcps);
+
+VL53L0X_Error VL53L0X_get_pal_range_status(VL53L0X_DEV Dev,
+		 uint8_t DeviceRangeStatus,
+		 FixPoint1616_t SignalRate,
+		 uint16_t EffectiveSpadRtnCount,
+		 VL53L0X_RangingMeasurementData_t *pRangingMeasurementData,
+		 uint8_t *pPalRangeStatus);
+
+uint32_t VL53L0X_calc_timeout_mclks(VL53L0X_DEV Dev,
+	uint32_t timeout_period_us, uint8_t vcsel_period_pclks);
+
+uint16_t VL53L0X_encode_timeout(uint32_t timeout_macro_clks);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_CORE_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_api_ranging.c

@@ -0,0 +1,42 @@
+/*******************************************************************************
+ Copyright <20> 2016, STMicroelectronics International N.V.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of STMicroelectronics nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+ NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+ IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include "vl53l0x_api.h"
+#include "vl53l0x_api_core.h"
+
+
+#ifndef __KERNEL__
+#include <stdlib.h>
+#endif
+#define LOG_FUNCTION_START(fmt, ...) \
+	_LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...) \
+	_LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...) \
+	_LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)
+

3rd-part/Simple_VL53L0X/vl53l0x_api_ranging.h

@@ -0,0 +1,47 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef _VL53L0X_API_RANGING_H_
+#define _VL53L0X_API_RANGING_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_API_RANGING_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_api_strings.c

@@ -0,0 +1,462 @@
+/*******************************************************************************
+ Copyright <20> 2016, STMicroelectronics International N.V.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+ * Neither the name of STMicroelectronics nor the
+ names of its contributors may be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+ NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+ IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ ******************************************************************************/
+
+#include "vl53l0x_api.h"
+#include "vl53l0x_api_core.h"
+#include "vl53l0x_api_strings.h"
+
+#ifndef __KERNEL__
+#include <stdlib.h>
+#endif
+
+#define LOG_FUNCTION_START(fmt, ...) \
+	_LOG_FUNCTION_START(TRACE_MODULE_API, fmt, ##__VA_ARGS__)
+#define LOG_FUNCTION_END(status, ...) \
+	_LOG_FUNCTION_END(TRACE_MODULE_API, status, ##__VA_ARGS__)
+#define LOG_FUNCTION_END_FMT(status, fmt, ...) \
+	_LOG_FUNCTION_END_FMT(TRACE_MODULE_API, status, fmt, ##__VA_ARGS__)
+
+
+VL53L0X_Error VL53L0X_check_part_used(VL53L0X_DEV Dev,
+		uint8_t *Revision,
+		VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+	uint8_t ModuleIdInt;
+	char *ProductId_tmp;
+
+	LOG_FUNCTION_START("");
+
+	Status = VL53L0X_get_info_from_device(Dev, 2);
+
+	if (Status == VL53L0X_ERROR_NONE) {
+		ModuleIdInt = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, ModuleId);
+
+	if (ModuleIdInt == 0) {
+		*Revision = 0;
+		VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, "");
+	} else {
+		*Revision = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, Revision);
+		ProductId_tmp = VL53L0X_GETDEVICESPECIFICPARAMETER(Dev,
+			ProductId);
+		VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->ProductId, ProductId_tmp);
+	}
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}
+
+
+VL53L0X_Error VL53L0X_get_device_info(VL53L0X_DEV Dev,
+				VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+	uint8_t revision_id;
+	uint8_t Revision;
+
+	Status = VL53L0X_check_part_used(Dev, &Revision, pVL53L0X_DeviceInfo);
+
+	if (Status == VL53L0X_ERROR_NONE) {
+		if (Revision == 0) {
+			VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+					VL53L0X_STRING_DEVICE_INFO_NAME_TS0);
+		} else if ((Revision <= 34) && (Revision != 32)) {
+			VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+					VL53L0X_STRING_DEVICE_INFO_NAME_TS1);
+		} else if (Revision < 39) {
+			VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+					VL53L0X_STRING_DEVICE_INFO_NAME_TS2);
+		} else {
+			VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Name,
+					VL53L0X_STRING_DEVICE_INFO_NAME_ES1);
+		}
+
+		VL53L0X_COPYSTRING(pVL53L0X_DeviceInfo->Type,
+				VL53L0X_STRING_DEVICE_INFO_TYPE);
+
+	}
+
+	if (Status == VL53L0X_ERROR_NONE) {
+		Status = VL53L0X_RdByte(Dev, VL53L0X_REG_IDENTIFICATION_MODEL_ID,
+				&pVL53L0X_DeviceInfo->ProductType);
+	}
+
+	if (Status == VL53L0X_ERROR_NONE) {
+		Status = VL53L0X_RdByte(Dev,
+			VL53L0X_REG_IDENTIFICATION_REVISION_ID,
+				&revision_id);
+		pVL53L0X_DeviceInfo->ProductRevisionMajor = 1;
+		pVL53L0X_DeviceInfo->ProductRevisionMinor =
+					(revision_id & 0xF0) >> 4;
+	}
+
+	return Status;
+}
+
+
+VL53L0X_Error VL53L0X_get_device_error_string(VL53L0X_DeviceError ErrorCode,
+		char *pDeviceErrorString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+	LOG_FUNCTION_START("");
+
+	switch (ErrorCode) {
+	case VL53L0X_DEVICEERROR_NONE:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_NONE);
+	break;
+	case VL53L0X_DEVICEERROR_VCSELCONTINUITYTESTFAILURE:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE);
+	break;
+	case VL53L0X_DEVICEERROR_VCSELWATCHDOGTESTFAILURE:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE);
+	break;
+	case VL53L0X_DEVICEERROR_NOVHVVALUEFOUND:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND);
+	break;
+	case VL53L0X_DEVICEERROR_MSRCNOTARGET:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET);
+	break;
+	case VL53L0X_DEVICEERROR_SNRCHECK:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_SNRCHECK);
+	break;
+	case VL53L0X_DEVICEERROR_RANGEPHASECHECK:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK);
+	break;
+	case VL53L0X_DEVICEERROR_SIGMATHRESHOLDCHECK:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK);
+	break;
+	case VL53L0X_DEVICEERROR_TCC:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_TCC);
+	break;
+	case VL53L0X_DEVICEERROR_PHASECONSISTENCY:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY);
+	break;
+	case VL53L0X_DEVICEERROR_MINCLIP:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_MINCLIP);
+	break;
+	case VL53L0X_DEVICEERROR_RANGECOMPLETE:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE);
+	break;
+	case VL53L0X_DEVICEERROR_ALGOUNDERFLOW:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW);
+	break;
+	case VL53L0X_DEVICEERROR_ALGOOVERFLOW:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW);
+	break;
+	case VL53L0X_DEVICEERROR_RANGEIGNORETHRESHOLD:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD);
+	break;
+
+	default:
+		VL53L0X_COPYSTRING(pDeviceErrorString,
+			VL53L0X_STRING_UNKNOW_ERROR_CODE);
+
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}
+
+VL53L0X_Error VL53L0X_get_range_status_string(uint8_t RangeStatus,
+		char *pRangeStatusString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+	LOG_FUNCTION_START("");
+
+	switch (RangeStatus) {
+	case 0:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_RANGEVALID);
+	break;
+	case 1:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_SIGMA);
+	break;
+	case 2:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_SIGNAL);
+	break;
+	case 3:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_MINRANGE);
+	break;
+	case 4:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_PHASE);
+	break;
+	case 5:
+		VL53L0X_COPYSTRING(pRangeStatusString,
+			VL53L0X_STRING_RANGESTATUS_HW);
+	break;
+
+	default: /**/
+		VL53L0X_COPYSTRING(pRangeStatusString,
+				VL53L0X_STRING_RANGESTATUS_NONE);
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}
+
+VL53L0X_Error VL53L0X_get_pal_error_string(VL53L0X_Error PalErrorCode,
+		char *pPalErrorString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+	LOG_FUNCTION_START("");
+
+	switch (PalErrorCode) {
+	case VL53L0X_ERROR_NONE:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_NONE);
+	break;
+	case VL53L0X_ERROR_CALIBRATION_WARNING:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_CALIBRATION_WARNING);
+	break;
+	case VL53L0X_ERROR_MIN_CLIPPED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_MIN_CLIPPED);
+	break;
+	case VL53L0X_ERROR_UNDEFINED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_UNDEFINED);
+	break;
+	case VL53L0X_ERROR_INVALID_PARAMS:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_INVALID_PARAMS);
+	break;
+	case VL53L0X_ERROR_NOT_SUPPORTED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_NOT_SUPPORTED);
+	break;
+	case VL53L0X_ERROR_INTERRUPT_NOT_CLEARED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED);
+	break;
+	case VL53L0X_ERROR_RANGE_ERROR:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_RANGE_ERROR);
+	break;
+	case VL53L0X_ERROR_TIME_OUT:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_TIME_OUT);
+	break;
+	case VL53L0X_ERROR_MODE_NOT_SUPPORTED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED);
+	break;
+	case VL53L0X_ERROR_BUFFER_TOO_SMALL:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL);
+	break;
+	case VL53L0X_ERROR_GPIO_NOT_EXISTING:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING);
+	break;
+	case VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED);
+	break;
+	case VL53L0X_ERROR_CONTROL_INTERFACE:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_CONTROL_INTERFACE);
+	break;
+	case VL53L0X_ERROR_INVALID_COMMAND:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_INVALID_COMMAND);
+	break;
+	case VL53L0X_ERROR_DIVISION_BY_ZERO:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_DIVISION_BY_ZERO);
+	break;
+	case VL53L0X_ERROR_REF_SPAD_INIT:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_REF_SPAD_INIT);
+	break;
+	case VL53L0X_ERROR_NOT_IMPLEMENTED:
+		VL53L0X_COPYSTRING(pPalErrorString,
+			VL53L0X_STRING_ERROR_NOT_IMPLEMENTED);
+	break;
+
+	default:
+		VL53L0X_COPYSTRING(pPalErrorString,
+				VL53L0X_STRING_UNKNOW_ERROR_CODE);
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}
+
+VL53L0X_Error VL53L0X_get_pal_state_string(VL53L0X_State PalStateCode,
+		char *pPalStateString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+	LOG_FUNCTION_START("");
+
+	switch (PalStateCode) {
+	case VL53L0X_STATE_POWERDOWN:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_POWERDOWN);
+	break;
+	case VL53L0X_STATE_WAIT_STATICINIT:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_WAIT_STATICINIT);
+	break;
+	case VL53L0X_STATE_STANDBY:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_STANDBY);
+	break;
+	case VL53L0X_STATE_IDLE:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_IDLE);
+	break;
+	case VL53L0X_STATE_RUNNING:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_RUNNING);
+	break;
+	case VL53L0X_STATE_UNKNOWN:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_UNKNOWN);
+	break;
+	case VL53L0X_STATE_ERROR:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_ERROR);
+	break;
+
+	default:
+		VL53L0X_COPYSTRING(pPalStateString,
+			VL53L0X_STRING_STATE_UNKNOWN);
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}
+
+VL53L0X_Error VL53L0X_get_sequence_steps_info(
+		VL53L0X_SequenceStepId SequenceStepId,
+		char *pSequenceStepsString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+	LOG_FUNCTION_START("");
+
+	switch (SequenceStepId) {
+	case VL53L0X_SEQUENCESTEP_TCC:
+		VL53L0X_COPYSTRING(pSequenceStepsString,
+			VL53L0X_STRING_SEQUENCESTEP_TCC);
+	break;
+	case VL53L0X_SEQUENCESTEP_DSS:
+		VL53L0X_COPYSTRING(pSequenceStepsString,
+			VL53L0X_STRING_SEQUENCESTEP_DSS);
+	break;
+	case VL53L0X_SEQUENCESTEP_MSRC:
+		VL53L0X_COPYSTRING(pSequenceStepsString,
+			VL53L0X_STRING_SEQUENCESTEP_MSRC);
+	break;
+	case VL53L0X_SEQUENCESTEP_PRE_RANGE:
+		VL53L0X_COPYSTRING(pSequenceStepsString,
+			VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE);
+	break;
+	case VL53L0X_SEQUENCESTEP_FINAL_RANGE:
+		VL53L0X_COPYSTRING(pSequenceStepsString,
+			VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE);
+	break;
+
+	default:
+		Status = VL53L0X_ERROR_INVALID_PARAMS;
+	}
+
+	LOG_FUNCTION_END(Status);
+
+	return Status;
+}
+
+
+VL53L0X_Error VL53L0X_get_limit_check_info(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+	char *pLimitCheckString)
+{
+	VL53L0X_Error Status = VL53L0X_ERROR_NONE;
+
+	LOG_FUNCTION_START("");
+
+	switch (LimitCheckId) {
+	case VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE);
+	break;
+	case VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE);
+	break;
+	case VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP);
+	break;
+	case VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD);
+	break;
+
+	case VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC);
+	break;
+
+	case VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE);
+	break;
+
+	default:
+		VL53L0X_COPYSTRING(pLimitCheckString,
+			VL53L0X_STRING_UNKNOW_ERROR_CODE);
+
+	}
+
+	LOG_FUNCTION_END(Status);
+	return Status;
+}

3rd-part/Simple_VL53L0X/vl53l0x_api_strings.h

@@ -0,0 +1,277 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+#ifndef VL53L0X_API_STRINGS_H_
+#define VL53L0X_API_STRINGS_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+VL53L0X_Error VL53L0X_get_device_info(VL53L0X_DEV Dev,
+			VL53L0X_DeviceInfo_t *pVL53L0X_DeviceInfo);
+
+VL53L0X_Error VL53L0X_get_device_error_string(VL53L0X_DeviceError ErrorCode,
+		char *pDeviceErrorString);
+
+VL53L0X_Error VL53L0X_get_range_status_string(uint8_t RangeStatus,
+		char *pRangeStatusString);
+
+VL53L0X_Error VL53L0X_get_pal_error_string(VL53L0X_Error PalErrorCode,
+		char *pPalErrorString);
+
+VL53L0X_Error VL53L0X_get_pal_state_string(VL53L0X_State PalStateCode,
+		char *pPalStateString);
+
+VL53L0X_Error VL53L0X_get_sequence_steps_info(
+		VL53L0X_SequenceStepId SequenceStepId,
+		char *pSequenceStepsString);
+
+VL53L0X_Error VL53L0X_get_limit_check_info(VL53L0X_DEV Dev, uint16_t LimitCheckId,
+	char *pLimitCheckString);
+
+
+#ifdef USE_EMPTY_STRING
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME                             ""
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS0                         ""
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS1                         ""
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS2                         ""
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_ES1                         ""
+	#define  VL53L0X_STRING_DEVICE_INFO_TYPE                             ""
+
+	/* PAL ERROR strings */
+	#define  VL53L0X_STRING_ERROR_NONE                                   ""
+	#define  VL53L0X_STRING_ERROR_CALIBRATION_WARNING                    ""
+	#define  VL53L0X_STRING_ERROR_MIN_CLIPPED                            ""
+	#define  VL53L0X_STRING_ERROR_UNDEFINED                              ""
+	#define  VL53L0X_STRING_ERROR_INVALID_PARAMS                         ""
+	#define  VL53L0X_STRING_ERROR_NOT_SUPPORTED                          ""
+	#define  VL53L0X_STRING_ERROR_RANGE_ERROR                            ""
+	#define  VL53L0X_STRING_ERROR_TIME_OUT                               ""
+	#define  VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED                     ""
+	#define  VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL                       ""
+	#define  VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING                      ""
+	#define  VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED       ""
+	#define  VL53L0X_STRING_ERROR_CONTROL_INTERFACE                      ""
+	#define  VL53L0X_STRING_ERROR_INVALID_COMMAND                        ""
+	#define  VL53L0X_STRING_ERROR_DIVISION_BY_ZERO                       ""
+	#define  VL53L0X_STRING_ERROR_REF_SPAD_INIT                          ""
+	#define  VL53L0X_STRING_ERROR_NOT_IMPLEMENTED                        ""
+
+	#define  VL53L0X_STRING_UNKNOW_ERROR_CODE                            ""
+
+
+
+	/* Range Status */
+	#define  VL53L0X_STRING_RANGESTATUS_NONE                             ""
+	#define  VL53L0X_STRING_RANGESTATUS_RANGEVALID                       ""
+	#define  VL53L0X_STRING_RANGESTATUS_SIGMA                            ""
+	#define  VL53L0X_STRING_RANGESTATUS_SIGNAL                           ""
+	#define  VL53L0X_STRING_RANGESTATUS_MINRANGE                         ""
+	#define  VL53L0X_STRING_RANGESTATUS_PHASE                            ""
+	#define  VL53L0X_STRING_RANGESTATUS_HW                               ""
+
+
+	/* Range Status */
+	#define  VL53L0X_STRING_STATE_POWERDOWN                              ""
+	#define  VL53L0X_STRING_STATE_WAIT_STATICINIT                        ""
+	#define  VL53L0X_STRING_STATE_STANDBY                                ""
+	#define  VL53L0X_STRING_STATE_IDLE                                   ""
+	#define  VL53L0X_STRING_STATE_RUNNING                                ""
+	#define  VL53L0X_STRING_STATE_UNKNOWN                                ""
+	#define  VL53L0X_STRING_STATE_ERROR                                  ""
+
+
+	/* Device Specific */
+	#define  VL53L0X_STRING_DEVICEERROR_NONE                             ""
+	#define  VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE       ""
+	#define  VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE         ""
+	#define  VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND                  ""
+	#define  VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET                     ""
+	#define  VL53L0X_STRING_DEVICEERROR_SNRCHECK                         ""
+	#define  VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK                  ""
+	#define  VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK              ""
+	#define  VL53L0X_STRING_DEVICEERROR_TCC                              ""
+	#define  VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY                 ""
+	#define  VL53L0X_STRING_DEVICEERROR_MINCLIP                          ""
+	#define  VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE                    ""
+	#define  VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW                    ""
+	#define  VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW                     ""
+	#define  VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD             ""
+	#define  VL53L0X_STRING_DEVICEERROR_UNKNOWN                          ""
+
+	/* Check Enable */
+	#define  VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE                ""
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE          ""
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP                  ""
+	#define  VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD           ""
+
+	/* Sequence Step */
+	#define  VL53L0X_STRING_SEQUENCESTEP_TCC                             ""
+	#define  VL53L0X_STRING_SEQUENCESTEP_DSS                             ""
+	#define  VL53L0X_STRING_SEQUENCESTEP_MSRC                            ""
+	#define  VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE                       ""
+	#define  VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE                     ""
+#else
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME          "VL53L0X cut1.0"
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS0      "VL53L0X TS0"
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS1      "VL53L0X TS1"
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_TS2      "VL53L0X TS2"
+	#define  VL53L0X_STRING_DEVICE_INFO_NAME_ES1      "VL53L0X ES1 or later"
+	#define  VL53L0X_STRING_DEVICE_INFO_TYPE          "VL53L0X"
+
+	/* PAL ERROR strings */
+	#define  VL53L0X_STRING_ERROR_NONE \
+			"No Error"
+	#define  VL53L0X_STRING_ERROR_CALIBRATION_WARNING \
+			"Calibration Warning Error"
+	#define  VL53L0X_STRING_ERROR_MIN_CLIPPED \
+			"Min clipped error"
+	#define  VL53L0X_STRING_ERROR_UNDEFINED \
+			"Undefined error"
+	#define  VL53L0X_STRING_ERROR_INVALID_PARAMS \
+			"Invalid parameters error"
+	#define  VL53L0X_STRING_ERROR_NOT_SUPPORTED \
+			"Not supported error"
+	#define  VL53L0X_STRING_ERROR_RANGE_ERROR \
+			"Range error"
+	#define  VL53L0X_STRING_ERROR_TIME_OUT \
+			"Time out error"
+	#define  VL53L0X_STRING_ERROR_MODE_NOT_SUPPORTED \
+			"Mode not supported error"
+	#define  VL53L0X_STRING_ERROR_BUFFER_TOO_SMALL \
+			"Buffer too small"
+	#define  VL53L0X_STRING_ERROR_GPIO_NOT_EXISTING \
+			"GPIO not existing"
+	#define  VL53L0X_STRING_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED \
+			"GPIO funct not supported"
+	#define  VL53L0X_STRING_ERROR_INTERRUPT_NOT_CLEARED \
+			"Interrupt not Cleared"
+	#define  VL53L0X_STRING_ERROR_CONTROL_INTERFACE \
+			"Control Interface Error"
+	#define  VL53L0X_STRING_ERROR_INVALID_COMMAND \
+			"Invalid Command Error"
+	#define  VL53L0X_STRING_ERROR_DIVISION_BY_ZERO \
+			"Division by zero Error"
+	#define  VL53L0X_STRING_ERROR_REF_SPAD_INIT \
+			"Reference Spad Init Error"
+	#define  VL53L0X_STRING_ERROR_NOT_IMPLEMENTED \
+			"Not implemented error"
+
+	#define  VL53L0X_STRING_UNKNOW_ERROR_CODE \
+			"Unknown Error Code"
+
+
+
+	/* Range Status */
+	#define  VL53L0X_STRING_RANGESTATUS_NONE                 "No Update"
+	#define  VL53L0X_STRING_RANGESTATUS_RANGEVALID           "Range Valid"
+	#define  VL53L0X_STRING_RANGESTATUS_SIGMA                "Sigma Fail"
+	#define  VL53L0X_STRING_RANGESTATUS_SIGNAL               "Signal Fail"
+	#define  VL53L0X_STRING_RANGESTATUS_MINRANGE             "Min Range Fail"
+	#define  VL53L0X_STRING_RANGESTATUS_PHASE                "Phase Fail"
+	#define  VL53L0X_STRING_RANGESTATUS_HW                   "Hardware Fail"
+
+
+	/* Range Status */
+	#define  VL53L0X_STRING_STATE_POWERDOWN               "POWERDOWN State"
+	#define  VL53L0X_STRING_STATE_WAIT_STATICINIT \
+			"Wait for staticinit State"
+	#define  VL53L0X_STRING_STATE_STANDBY                 "STANDBY State"
+	#define  VL53L0X_STRING_STATE_IDLE                    "IDLE State"
+	#define  VL53L0X_STRING_STATE_RUNNING                 "RUNNING State"
+	#define  VL53L0X_STRING_STATE_UNKNOWN                 "UNKNOWN State"
+	#define  VL53L0X_STRING_STATE_ERROR                   "ERROR State"
+
+
+	/* Device Specific */
+	#define  VL53L0X_STRING_DEVICEERROR_NONE                   "No Update"
+	#define  VL53L0X_STRING_DEVICEERROR_VCSELCONTINUITYTESTFAILURE \
+			"VCSEL Continuity Test Failure"
+	#define  VL53L0X_STRING_DEVICEERROR_VCSELWATCHDOGTESTFAILURE \
+			"VCSEL Watchdog Test Failure"
+	#define  VL53L0X_STRING_DEVICEERROR_NOVHVVALUEFOUND \
+			"No VHV Value found"
+	#define  VL53L0X_STRING_DEVICEERROR_MSRCNOTARGET \
+			"MSRC No Target Error"
+	#define  VL53L0X_STRING_DEVICEERROR_SNRCHECK \
+			"SNR Check Exit"
+	#define  VL53L0X_STRING_DEVICEERROR_RANGEPHASECHECK \
+			"Range Phase Check Error"
+	#define  VL53L0X_STRING_DEVICEERROR_SIGMATHRESHOLDCHECK \
+			"Sigma Threshold Check Error"
+	#define  VL53L0X_STRING_DEVICEERROR_TCC \
+			"TCC Error"
+	#define  VL53L0X_STRING_DEVICEERROR_PHASECONSISTENCY \
+			"Phase Consistency Error"
+	#define  VL53L0X_STRING_DEVICEERROR_MINCLIP \
+			"Min Clip Error"
+	#define  VL53L0X_STRING_DEVICEERROR_RANGECOMPLETE \
+			"Range Complete"
+	#define  VL53L0X_STRING_DEVICEERROR_ALGOUNDERFLOW \
+			"Range Algo Underflow Error"
+	#define  VL53L0X_STRING_DEVICEERROR_ALGOOVERFLOW \
+			"Range Algo Overlow Error"
+	#define  VL53L0X_STRING_DEVICEERROR_RANGEIGNORETHRESHOLD \
+			"Range Ignore Threshold Error"
+	#define  VL53L0X_STRING_DEVICEERROR_UNKNOWN \
+			"Unknown error code"
+
+	/* Check Enable */
+	#define  VL53L0X_STRING_CHECKENABLE_SIGMA_FINAL_RANGE \
+			"SIGMA FINAL RANGE"
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE \
+			"SIGNAL RATE FINAL RANGE"
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_REF_CLIP \
+			"SIGNAL REF CLIP"
+	#define  VL53L0X_STRING_CHECKENABLE_RANGE_IGNORE_THRESHOLD \
+			"RANGE IGNORE THRESHOLD"
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_MSRC \
+			"SIGNAL RATE MSRC"
+	#define  VL53L0X_STRING_CHECKENABLE_SIGNAL_RATE_PRE_RANGE \
+			"SIGNAL RATE PRE RANGE"
+
+	/* Sequence Step */
+	#define  VL53L0X_STRING_SEQUENCESTEP_TCC                   "TCC"
+	#define  VL53L0X_STRING_SEQUENCESTEP_DSS                   "DSS"
+	#define  VL53L0X_STRING_SEQUENCESTEP_MSRC                  "MSRC"
+	#define  VL53L0X_STRING_SEQUENCESTEP_PRE_RANGE             "PRE RANGE"
+	#define  VL53L0X_STRING_SEQUENCESTEP_FINAL_RANGE           "FINAL RANGE"
+#endif /* USE_EMPTY_STRING */
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+

3rd-part/Simple_VL53L0X/vl53l0x_def.h

@@ -0,0 +1,640 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of STMicroelectronics nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+/**
+ * @file VL53L0X_def.h
+ *
+ * @brief Type definitions for VL53L0X API.
+ *
+ */
+
+
+#ifndef _VL53L0X_DEF_H_
+#define _VL53L0X_DEF_H_
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/** @defgroup VL53L0X_globaldefine_group VL53L0X Defines
+ *	@brief	  VL53L0X Defines
+ *	@{
+ */
+
+
+/** PAL SPECIFICATION major version */
+#define VL53L0X10_SPECIFICATION_VER_MAJOR   1
+/** PAL SPECIFICATION minor version */
+#define VL53L0X10_SPECIFICATION_VER_MINOR   2
+/** PAL SPECIFICATION sub version */
+#define VL53L0X10_SPECIFICATION_VER_SUB	   7
+/** PAL SPECIFICATION sub version */
+#define VL53L0X10_SPECIFICATION_VER_REVISION 1440
+
+/** VL53L0X PAL IMPLEMENTATION major version */
+#define VL53L0X10_IMPLEMENTATION_VER_MAJOR	1
+/** VL53L0X PAL IMPLEMENTATION minor version */
+#define VL53L0X10_IMPLEMENTATION_VER_MINOR	0
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X10_IMPLEMENTATION_VER_SUB		9
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X10_IMPLEMENTATION_VER_REVISION	3673
+
+/** PAL SPECIFICATION major version */
+#define VL53L0X_SPECIFICATION_VER_MAJOR	 1
+/** PAL SPECIFICATION minor version */
+#define VL53L0X_SPECIFICATION_VER_MINOR	 2
+/** PAL SPECIFICATION sub version */
+#define VL53L0X_SPECIFICATION_VER_SUB	 7
+/** PAL SPECIFICATION sub version */
+#define VL53L0X_SPECIFICATION_VER_REVISION 1440
+
+/** VL53L0X PAL IMPLEMENTATION major version */
+#define VL53L0X_IMPLEMENTATION_VER_MAJOR	  1
+/** VL53L0X PAL IMPLEMENTATION minor version */
+#define VL53L0X_IMPLEMENTATION_VER_MINOR	  0
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X_IMPLEMENTATION_VER_SUB	  2
+/** VL53L0X PAL IMPLEMENTATION sub version */
+#define VL53L0X_IMPLEMENTATION_VER_REVISION	  4823
+#define VL53L0X_DEFAULT_MAX_LOOP 2000
+#define VL53L0X_MAX_STRING_LENGTH 32
+
+
+#include "vl53l0x_device.h"
+#include "vl53l0x_types.h"
+
+
+/****************************************
+ * PRIVATE define do not edit
+ ****************************************/
+
+/** @brief Defines the parameters of the Get Version Functions
+ */
+typedef struct {
+	uint32_t	 revision; /*!< revision number */
+	uint8_t		 major;	   /*!< major number */
+	uint8_t		 minor;	   /*!< minor number */
+	uint8_t		 build;	   /*!< build number */
+} VL53L0X_Version_t;
+
+
+/** @brief Defines the parameters of the Get Device Info Functions
+ */
+typedef struct {
+	char Name[VL53L0X_MAX_STRING_LENGTH];
+		/*!< Name of the Device e.g. Left_Distance */
+	char Type[VL53L0X_MAX_STRING_LENGTH];
+		/*!< Type of the Device e.g VL53L0X */
+	char ProductId[VL53L0X_MAX_STRING_LENGTH];
+		/*!< Product Identifier String	*/
+	uint8_t ProductType;
+		/*!< Product Type, VL53L0X = 1, VL53L1 = 2 */
+	uint8_t ProductRevisionMajor;
+		/*!< Product revision major */
+	uint8_t ProductRevisionMinor;
+		/*!< Product revision minor */
+} VL53L0X_DeviceInfo_t;
+
+
+/** @defgroup VL53L0X_define_Error_group Error and Warning code returned by API
+ *	The following DEFINE are used to identify the PAL ERROR
+ *	@{
+ */
+
+typedef int8_t VL53L0X_Error;
+
+#define VL53L0X_ERROR_NONE		((VL53L0X_Error)	0)
+#define VL53L0X_ERROR_CALIBRATION_WARNING	((VL53L0X_Error) -1)
+	/*!< Warning invalid calibration data may be in used
+		\a	VL53L0X_InitData()
+		\a VL53L0X_GetOffsetCalibrationData
+		\a VL53L0X_SetOffsetCalibrationData */
+#define VL53L0X_ERROR_MIN_CLIPPED			((VL53L0X_Error) -2)
+	/*!< Warning parameter passed was clipped to min before to be applied */
+
+#define VL53L0X_ERROR_UNDEFINED				((VL53L0X_Error) -3)
+	/*!< Unqualified error */
+#define VL53L0X_ERROR_INVALID_PARAMS			((VL53L0X_Error) -4)
+	/*!< Parameter passed is invalid or out of range */
+#define VL53L0X_ERROR_NOT_SUPPORTED			((VL53L0X_Error) -5)
+	/*!< Function is not supported in current mode or configuration */
+#define VL53L0X_ERROR_RANGE_ERROR			((VL53L0X_Error) -6)
+	/*!< Device report a ranging error interrupt status */
+#define VL53L0X_ERROR_TIME_OUT				((VL53L0X_Error) -7)
+	/*!< Aborted due to time out */
+#define VL53L0X_ERROR_MODE_NOT_SUPPORTED			((VL53L0X_Error) -8)
+	/*!< Asked mode is not supported by the device */
+#define VL53L0X_ERROR_BUFFER_TOO_SMALL			((VL53L0X_Error) -9)
+	/*!< ... */
+#define VL53L0X_ERROR_GPIO_NOT_EXISTING			((VL53L0X_Error) -10)
+	/*!< User tried to setup a non-existing GPIO pin */
+#define VL53L0X_ERROR_GPIO_FUNCTIONALITY_NOT_SUPPORTED  ((VL53L0X_Error) -11)
+	/*!< unsupported GPIO functionality */
+#define VL53L0X_ERROR_INTERRUPT_NOT_CLEARED		((VL53L0X_Error) -12)
+	/*!< Error during interrupt clear */
+#define VL53L0X_ERROR_CONTROL_INTERFACE			((VL53L0X_Error) -20)
+	/*!< error reported from IO functions */
+#define VL53L0X_ERROR_INVALID_COMMAND			((VL53L0X_Error) -30)
+	/*!< The command is not allowed in the current device state
+	 *	(power down) */
+#define VL53L0X_ERROR_DIVISION_BY_ZERO			((VL53L0X_Error) -40)
+	/*!< In the function a division by zero occurs */
+#define VL53L0X_ERROR_REF_SPAD_INIT			((VL53L0X_Error) -50)
+	/*!< Error during reference SPAD initialization */
+#define VL53L0X_ERROR_NOT_IMPLEMENTED			((VL53L0X_Error) -99)
+	/*!< Tells requested functionality has not been implemented yet or
+	 * not compatible with the device */
+/** @} VL53L0X_define_Error_group */
+
+
+/** @defgroup VL53L0X_define_DeviceModes_group Defines Device modes
+ *	Defines all possible modes for the device
+ *	@{
+ */
+typedef uint8_t VL53L0X_DeviceModes;
+
+#define VL53L0X_DEVICEMODE_SINGLE_RANGING	((VL53L0X_DeviceModes)  0)
+#define VL53L0X_DEVICEMODE_CONTINUOUS_RANGING	((VL53L0X_DeviceModes)  1)
+#define VL53L0X_DEVICEMODE_SINGLE_HISTOGRAM	((VL53L0X_DeviceModes)  2)
+#define VL53L0X_DEVICEMODE_CONTINUOUS_TIMED_RANGING ((VL53L0X_DeviceModes) 3)
+#define VL53L0X_DEVICEMODE_SINGLE_ALS		((VL53L0X_DeviceModes) 10)
+#define VL53L0X_DEVICEMODE_GPIO_DRIVE		((VL53L0X_DeviceModes) 20)
+#define VL53L0X_DEVICEMODE_GPIO_OSC		((VL53L0X_DeviceModes) 21)
+	/* ... Modes to be added depending on device */
+/** @} VL53L0X_define_DeviceModes_group */
+
+
+
+/** @defgroup VL53L0X_define_HistogramModes_group Defines Histogram modes
+ *	Defines all possible Histogram modes for the device
+ *	@{
+ */
+typedef uint8_t VL53L0X_HistogramModes;
+
+#define VL53L0X_HISTOGRAMMODE_DISABLED		((VL53L0X_HistogramModes) 0)
+	/*!< Histogram Disabled */
+#define VL53L0X_HISTOGRAMMODE_REFERENCE_ONLY	((VL53L0X_HistogramModes) 1)
+	/*!< Histogram Reference array only */
+#define VL53L0X_HISTOGRAMMODE_RETURN_ONLY	((VL53L0X_HistogramModes) 2)
+	/*!< Histogram Return array only */
+#define VL53L0X_HISTOGRAMMODE_BOTH		((VL53L0X_HistogramModes) 3)
+	/*!< Histogram both Reference and Return Arrays */
+	/* ... Modes to be added depending on device */
+/** @} VL53L0X_define_HistogramModes_group */
+
+
+/** @defgroup VL53L0X_define_PowerModes_group List of available Power Modes
+ *	List of available Power Modes
+ *	@{
+ */
+
+typedef uint8_t VL53L0X_PowerModes;
+
+#define VL53L0X_POWERMODE_STANDBY_LEVEL1 ((VL53L0X_PowerModes) 0)
+	/*!< Standby level 1 */
+#define VL53L0X_POWERMODE_STANDBY_LEVEL2 ((VL53L0X_PowerModes) 1)
+	/*!< Standby level 2 */
+#define VL53L0X_POWERMODE_IDLE_LEVEL1	((VL53L0X_PowerModes) 2)
+	/*!< Idle level 1 */
+#define VL53L0X_POWERMODE_IDLE_LEVEL2	((VL53L0X_PowerModes) 3)
+	/*!< Idle level 2 */
+
+/** @} VL53L0X_define_PowerModes_group */
+
+
+/** @brief Defines all parameters for the device
+ */
+typedef struct {
+	VL53L0X_DeviceModes DeviceMode;
+	/*!< Defines type of measurement to be done for the next measure */
+	VL53L0X_HistogramModes HistogramMode;
+	/*!< Defines type of histogram measurement to be done for the next
+	 *	measure */
+	uint32_t MeasurementTimingBudgetMicroSeconds;
+	/*!< Defines the allowed total time for a single measurement */
+	uint32_t InterMeasurementPeriodMilliSeconds;
+	/*!< Defines time between two consecutive measurements (between two
+	 *	measurement starts). If set to 0 means back-to-back mode */
+	uint8_t XTalkCompensationEnable;
+	/*!< Tells if Crosstalk compensation shall be enable or not	 */
+	uint16_t XTalkCompensationRangeMilliMeter;
+	/*!< CrossTalk compensation range in millimeter	 */
+	FixPoint1616_t XTalkCompensationRateMegaCps;
+	/*!< CrossTalk compensation rate in Mega counts per seconds.
+	 *	Expressed in 16.16 fixed point format.	*/
+	int32_t RangeOffsetMicroMeters;
+	/*!< Range offset adjustment (mm).	*/
+
+	uint8_t LimitChecksEnable[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+	/*!< This Array store all the Limit Check enable for this device. */
+	uint8_t LimitChecksStatus[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+	/*!< This Array store all the Status of the check linked to last
+	* measurement. */
+	FixPoint1616_t LimitChecksValue[VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS];
+	/*!< This Array store all the Limit Check value for this device */
+
+	uint8_t WrapAroundCheckEnable;
+	/*!< Tells if Wrap Around Check shall be enable or not */
+} VL53L0X_DeviceParameters_t;
+
+
+/** @defgroup VL53L0X_define_State_group Defines the current status of the device
+ *	Defines the current status of the device
+ *	@{
+ */
+
+typedef uint8_t VL53L0X_State;
+
+#define VL53L0X_STATE_POWERDOWN		 ((VL53L0X_State)  0)
+	/*!< Device is in HW reset	*/
+#define VL53L0X_STATE_WAIT_STATICINIT ((VL53L0X_State)  1)
+	/*!< Device is initialized and wait for static initialization  */
+#define VL53L0X_STATE_STANDBY		 ((VL53L0X_State)  2)
+	/*!< Device is in Low power Standby mode   */
+#define VL53L0X_STATE_IDLE			 ((VL53L0X_State)  3)
+	/*!< Device has been initialized and ready to do measurements  */
+#define VL53L0X_STATE_RUNNING		 ((VL53L0X_State)  4)
+	/*!< Device is performing measurement */
+#define VL53L0X_STATE_UNKNOWN		 ((VL53L0X_State)  98)
+	/*!< Device is in unknown state and need to be rebooted	 */
+#define VL53L0X_STATE_ERROR			 ((VL53L0X_State)  99)
+	/*!< Device is in error state and need to be rebooted  */
+
+/** @} VL53L0X_define_State_group */
+
+
+/** @brief Structure containing the Dmax computation parameters and data
+ */
+typedef struct {
+	int32_t AmbTuningWindowFactor_K;
+		/*!<  internal algo tuning (*1000) */
+	int32_t RetSignalAt0mm;
+		/*!< intermediate dmax computation value caching */
+} VL53L0X_DMaxData_t;
+
+/**
+ * @struct VL53L0X_RangeData_t
+ * @brief Range measurement data.
+ */
+typedef struct {
+	uint32_t TimeStamp;		/*!< 32-bit time stamp. */
+	uint32_t MeasurementTimeUsec;
+		/*!< Give the Measurement time needed by the device to do the
+		 * measurement.*/
+
+
+	uint16_t RangeMilliMeter;	/*!< range distance in millimeter. */
+
+	uint16_t RangeDMaxMilliMeter;
+		/*!< Tells what is the maximum detection distance of the device
+		 * in current setup and environment conditions (Filled when
+		 *	applicable) */
+
+	FixPoint1616_t SignalRateRtnMegaCps;
+		/*!< Return signal rate (MCPS)\n these is a 16.16 fix point
+		 *	value, which is effectively a measure of target
+		 *	 reflectance.*/
+	FixPoint1616_t AmbientRateRtnMegaCps;
+		/*!< Return ambient rate (MCPS)\n these is a 16.16 fix point
+		 *	value, which is effectively a measure of the ambien
+		 *	t light.*/
+
+	uint16_t EffectiveSpadRtnCount;
+		/*!< Return the effective SPAD count for the return signal.
+		 *	To obtain Real value it should be divided by 256 */
+
+	uint8_t ZoneId;
+		/*!< Denotes which zone and range scheduler stage the range
+		 *	data relates to. */
+	uint8_t RangeFractionalPart;
+		/*!< Fractional part of range distance. Final value is a
+		 *	FixPoint168 value. */
+	uint8_t RangeStatus;
+		/*!< Range Status for the current measurement. This is device
+		 *	dependent. Value = 0 means value is valid.
+		 *	See \ref RangeStatusPage */
+} VL53L0X_RangingMeasurementData_t;
+
+
+#define VL53L0X_HISTOGRAM_BUFFER_SIZE 24
+
+/**
+ * @struct VL53L0X_HistogramData_t
+ * @brief Histogram measurement data.
+ */
+typedef struct {
+	/* Histogram Measurement data */
+	uint32_t HistogramData[VL53L0X_HISTOGRAM_BUFFER_SIZE];
+	/*!< Histogram data */
+	uint8_t HistogramType; /*!< Indicate the types of histogram data :
+	Return only, Reference only, both Return and Reference */
+	uint8_t FirstBin; /*!< First Bin value */
+	uint8_t BufferSize; /*!< Buffer Size - Set by the user.*/
+	uint8_t NumberOfBins;
+	/*!< Number of bins filled by the histogram measurement */
+
+	VL53L0X_DeviceError ErrorStatus;
+	/*!< Error status of the current measurement. \n
+	see @a ::VL53L0X_DeviceError @a VL53L0X_GetStatusErrorString() */
+} VL53L0X_HistogramMeasurementData_t;
+
+#define VL53L0X_REF_SPAD_BUFFER_SIZE 6
+
+/**
+ * @struct VL53L0X_SpadData_t
+ * @brief Spad Configuration Data.
+ */
+typedef struct {
+	uint8_t RefSpadEnables[VL53L0X_REF_SPAD_BUFFER_SIZE];
+	/*!< Reference Spad Enables */
+	uint8_t RefGoodSpadMap[VL53L0X_REF_SPAD_BUFFER_SIZE];
+	/*!< Reference Spad Good Spad Map */
+} VL53L0X_SpadData_t;
+
+typedef struct {
+	FixPoint1616_t OscFrequencyMHz; /* Frequency used */
+
+	uint16_t LastEncodedTimeout;
+	/* last encoded Time out used for timing budget*/
+
+	VL53L0X_GpioFunctionality Pin0GpioFunctionality;
+	/* store the functionality of the GPIO: pin0 */
+
+	uint32_t FinalRangeTimeoutMicroSecs;
+	 /*!< Execution time of the final range*/
+	uint8_t FinalRangeVcselPulsePeriod;
+	 /*!< Vcsel pulse period (pll clocks) for the final range measurement*/
+	uint32_t PreRangeTimeoutMicroSecs;
+	 /*!< Execution time of the final range*/
+	uint8_t PreRangeVcselPulsePeriod;
+	 /*!< Vcsel pulse period (pll clocks) for the pre-range measurement*/
+
+	uint16_t SigmaEstRefArray;
+	 /*!< Reference array sigma value in 1/100th of [mm] e.g. 100 = 1mm */
+	uint16_t SigmaEstEffPulseWidth;
+	 /*!< Effective Pulse width for sigma estimate in 1/100th
+	  * of ns e.g. 900 = 9.0ns */
+	uint16_t SigmaEstEffAmbWidth;
+	 /*!< Effective Ambient width for sigma estimate in 1/100th of ns
+	  * e.g. 500 = 5.0ns */
+
+
+	uint8_t ReadDataFromDeviceDone; /* Indicate if read from device has
+	been done (==1) or not (==0) */
+	uint8_t ModuleId; /* Module ID */
+	uint8_t Revision; /* test Revision */
+	char ProductId[VL53L0X_MAX_STRING_LENGTH];
+		/* Product Identifier String  */
+	uint8_t ReferenceSpadCount; /* used for ref spad management */
+	uint8_t ReferenceSpadType;	/* used for ref spad management */
+	uint8_t RefSpadsInitialised; /* reports if ref spads are initialised. */
+	uint32_t PartUIDUpper; /*!< Unique Part ID Upper */
+	uint32_t PartUIDLower; /*!< Unique Part ID Lower */
+	FixPoint1616_t SignalRateMeasFixed400mm; /*!< Peek Signal rate
+	at 400 mm*/
+
+} VL53L0X_DeviceSpecificParameters_t;
+
+/**
+ * @struct VL53L0X_DevData_t
+ *
+ * @brief VL53L0X PAL device ST private data structure \n
+ * End user should never access any of these field directly
+ *
+ * These must never access directly but only via macro
+ */
+typedef struct {
+	VL53L0X_DMaxData_t DMaxData;
+	/*!< Dmax Data */
+	int32_t	 Part2PartOffsetNVMMicroMeter;
+	/*!< backed up NVM value */
+	int32_t	 Part2PartOffsetAdjustmentNVMMicroMeter;
+	/*!< backed up NVM value representing additional offset adjustment */
+	VL53L0X_DeviceParameters_t CurrentParameters;
+	/*!< Current Device Parameter */
+	VL53L0X_RangingMeasurementData_t LastRangeMeasure;
+	/*!< Ranging Data */
+	VL53L0X_HistogramMeasurementData_t LastHistogramMeasure;
+	/*!< Histogram Data */
+	VL53L0X_DeviceSpecificParameters_t DeviceSpecificParameters;
+	/*!< Parameters specific to the device */
+	VL53L0X_SpadData_t SpadData;
+	/*!< Spad Data */
+	uint8_t SequenceConfig;
+	/*!< Internal value for the sequence config */
+	uint8_t RangeFractionalEnable;
+	/*!< Enable/Disable fractional part of ranging data */
+	VL53L0X_State PalState;
+	/*!< Current state of the PAL for this device */
+	VL53L0X_PowerModes PowerMode;
+	/*!< Current Power Mode	 */
+	uint16_t SigmaEstRefArray;
+	/*!< Reference array sigma value in 1/100th of [mm] e.g. 100 = 1mm */
+	uint16_t SigmaEstEffPulseWidth;
+	/*!< Effective Pulse width for sigma estimate in 1/100th
+	* of ns e.g. 900 = 9.0ns */
+	uint16_t SigmaEstEffAmbWidth;
+	/*!< Effective Ambient width for sigma estimate in 1/100th of ns
+	* e.g. 500 = 5.0ns */
+	uint8_t StopVariable;
+	/*!< StopVariable used during the stop sequence */
+	uint16_t targetRefRate;
+	/*!< Target Ambient Rate for Ref spad management */
+	FixPoint1616_t SigmaEstimate;
+	/*!< Sigma Estimate - based on ambient & VCSEL rates and
+	* signal_total_events */
+	FixPoint1616_t SignalEstimate;
+	/*!< Signal Estimate - based on ambient & VCSEL rates and cross talk */
+	FixPoint1616_t LastSignalRefMcps;
+	/*!< Latest Signal ref in Mcps */
+	uint8_t *pTuningSettingsPointer;
+	/*!< Pointer for Tuning Settings table */
+	uint8_t UseInternalTuningSettings;
+	/*!< Indicate if we use	 Tuning Settings table */
+	uint16_t LinearityCorrectiveGain;
+	/*!< Linearity Corrective Gain value in x1000 */
+	uint16_t DmaxCalRangeMilliMeter;
+	/*!< Dmax Calibration Range millimeter */
+	FixPoint1616_t DmaxCalSignalRateRtnMegaCps;
+	/*!< Dmax Calibration Signal Rate Return MegaCps */
+
+} VL53L0X_DevData_t;
+
+
+/** @defgroup VL53L0X_define_InterruptPolarity_group Defines the Polarity
+ * of the Interrupt
+ *	Defines the Polarity of the Interrupt
+ *	@{
+ */
+typedef uint8_t VL53L0X_InterruptPolarity;
+
+#define VL53L0X_INTERRUPTPOLARITY_LOW	   ((VL53L0X_InterruptPolarity)	0)
+/*!< Set active low polarity best setup for falling edge. */
+#define VL53L0X_INTERRUPTPOLARITY_HIGH	   ((VL53L0X_InterruptPolarity)	1)
+/*!< Set active high polarity best setup for rising edge. */
+
+/** @} VL53L0X_define_InterruptPolarity_group */
+
+
+/** @defgroup VL53L0X_define_VcselPeriod_group Vcsel Period Defines
+ *	Defines the range measurement for which to access the vcsel period.
+ *	@{
+ */
+typedef uint8_t VL53L0X_VcselPeriod;
+
+#define VL53L0X_VCSEL_PERIOD_PRE_RANGE	((VL53L0X_VcselPeriod) 0)
+/*!<Identifies the pre-range vcsel period. */
+#define VL53L0X_VCSEL_PERIOD_FINAL_RANGE ((VL53L0X_VcselPeriod) 1)
+/*!<Identifies the final range vcsel period. */
+
+/** @} VL53L0X_define_VcselPeriod_group */
+
+/** @defgroup VL53L0X_define_SchedulerSequence_group Defines the steps
+ * carried out by the scheduler during a range measurement.
+ *	@{
+ *	Defines the states of all the steps in the scheduler
+ *	i.e. enabled/disabled.
+ */
+typedef struct {
+	uint8_t		 TccOn;	   /*!<Reports if Target Centre Check On  */
+	uint8_t		 MsrcOn;	   /*!<Reports if MSRC On  */
+	uint8_t		 DssOn;		   /*!<Reports if DSS On  */
+	uint8_t		 PreRangeOn;   /*!<Reports if Pre-Range On	*/
+	uint8_t		 FinalRangeOn; /*!<Reports if Final-Range On  */
+} VL53L0X_SchedulerSequenceSteps_t;
+
+/** @} VL53L0X_define_SchedulerSequence_group */
+
+/** @defgroup VL53L0X_define_SequenceStepId_group Defines the Polarity
+ *	of the Interrupt
+ *	Defines the the sequence steps performed during ranging..
+ *	@{
+ */
+typedef uint8_t VL53L0X_SequenceStepId;
+
+#define	 VL53L0X_SEQUENCESTEP_TCC		 ((VL53L0X_VcselPeriod) 0)
+/*!<Target CentreCheck identifier. */
+#define	 VL53L0X_SEQUENCESTEP_DSS		 ((VL53L0X_VcselPeriod) 1)
+/*!<Dynamic Spad Selection function Identifier. */
+#define	 VL53L0X_SEQUENCESTEP_MSRC		 ((VL53L0X_VcselPeriod) 2)
+/*!<Minimum Signal Rate Check function Identifier. */
+#define	 VL53L0X_SEQUENCESTEP_PRE_RANGE	 ((VL53L0X_VcselPeriod) 3)
+/*!<Pre-Range check Identifier. */
+#define	 VL53L0X_SEQUENCESTEP_FINAL_RANGE ((VL53L0X_VcselPeriod) 4)
+/*!<Final Range Check Identifier. */
+
+#define	 VL53L0X_SEQUENCESTEP_NUMBER_OF_CHECKS			 5
+/*!<Number of Sequence Step Managed by the API. */
+
+/** @} VL53L0X_define_SequenceStepId_group */
+
+
+/* MACRO Definitions */
+/** @defgroup VL53L0X_define_GeneralMacro_group General Macro Defines
+ *	General Macro Defines
+ *	@{
+ */
+
+/* Defines */
+#define VL53L0X_SETPARAMETERFIELD(Dev, field, value) \
+	PALDevDataSet(Dev, CurrentParameters.field, value)
+
+#define VL53L0X_GETPARAMETERFIELD(Dev, field, variable) \
+	variable = PALDevDataGet(Dev, CurrentParameters).field
+
+
+#define VL53L0X_SETARRAYPARAMETERFIELD(Dev, field, index, value) \
+	PALDevDataSet(Dev, CurrentParameters.field[index], value)
+
+#define VL53L0X_GETARRAYPARAMETERFIELD(Dev, field, index, variable) \
+	variable = PALDevDataGet(Dev, CurrentParameters).field[index]
+
+
+#define VL53L0X_SETDEVICESPECIFICPARAMETER(Dev, field, value) \
+		PALDevDataSet(Dev, DeviceSpecificParameters.field, value)
+
+#define VL53L0X_GETDEVICESPECIFICPARAMETER(Dev, field) \
+		PALDevDataGet(Dev, DeviceSpecificParameters).field
+
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT97(Value) \
+	(uint16_t)((Value>>9)&0xFFFF)
+#define VL53L0X_FIXPOINT97TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<9)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT88(Value) \
+	(uint16_t)((Value>>8)&0xFFFF)
+#define VL53L0X_FIXPOINT88TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<8)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT412(Value) \
+	(uint16_t)((Value>>4)&0xFFFF)
+#define VL53L0X_FIXPOINT412TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<4)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT313(Value) \
+	(uint16_t)((Value>>3)&0xFFFF)
+#define VL53L0X_FIXPOINT313TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<3)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT08(Value) \
+	(uint8_t)((Value>>8)&0x00FF)
+#define VL53L0X_FIXPOINT08TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<8)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT53(Value) \
+	(uint8_t)((Value>>13)&0x00FF)
+#define VL53L0X_FIXPOINT53TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<13)
+
+#define VL53L0X_FIXPOINT1616TOFIXPOINT102(Value) \
+	(uint16_t)((Value>>14)&0x0FFF)
+#define VL53L0X_FIXPOINT102TOFIXPOINT1616(Value) \
+	(FixPoint1616_t)(Value<<12)
+
+#define VL53L0X_MAKEUINT16(lsb, msb) (uint16_t)((((uint16_t)msb)<<8) + \
+		(uint16_t)lsb)
+
+/** @} VL53L0X_define_GeneralMacro_group */
+
+/** @} VL53L0X_globaldefine_group */
+
+
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* _VL53L0X_DEF_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_device.h

@@ -0,0 +1,257 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+/**
+ * Device specific defines. To be adapted by implementer for the targeted
+ * device.
+ */
+
+#ifndef _VL53L0X_DEVICE_H_
+#define _VL53L0X_DEVICE_H_
+
+#include "vl53l0x_types.h"
+
+
+/** @defgroup VL53L0X_DevSpecDefines_group VL53L0X cut1.1 Device Specific Defines
+ *  @brief VL53L0X cut1.1 Device Specific Defines
+ *  @{
+ */
+
+
+/** @defgroup VL53L0X_DeviceError_group Device Error
+ *  @brief Device Error code
+ *
+ *  This enum is Device specific it should be updated in the implementation
+ *  Use @a VL53L0X_GetStatusErrorString() to get the string.
+ *  It is related to Status Register of the Device.
+ *  @{
+ */
+typedef uint8_t VL53L0X_DeviceError;
+
+#define VL53L0X_DEVICEERROR_NONE                        ((VL53L0X_DeviceError) 0)
+	/*!< 0  NoError  */
+#define VL53L0X_DEVICEERROR_VCSELCONTINUITYTESTFAILURE  ((VL53L0X_DeviceError) 1)
+#define VL53L0X_DEVICEERROR_VCSELWATCHDOGTESTFAILURE    ((VL53L0X_DeviceError) 2)
+#define VL53L0X_DEVICEERROR_NOVHVVALUEFOUND             ((VL53L0X_DeviceError) 3)
+#define VL53L0X_DEVICEERROR_MSRCNOTARGET                ((VL53L0X_DeviceError) 4)
+#define VL53L0X_DEVICEERROR_SNRCHECK                    ((VL53L0X_DeviceError) 5)
+#define VL53L0X_DEVICEERROR_RANGEPHASECHECK             ((VL53L0X_DeviceError) 6)
+#define VL53L0X_DEVICEERROR_SIGMATHRESHOLDCHECK         ((VL53L0X_DeviceError) 7)
+#define VL53L0X_DEVICEERROR_TCC                         ((VL53L0X_DeviceError) 8)
+#define VL53L0X_DEVICEERROR_PHASECONSISTENCY            ((VL53L0X_DeviceError) 9)
+#define VL53L0X_DEVICEERROR_MINCLIP                     ((VL53L0X_DeviceError) 10)
+#define VL53L0X_DEVICEERROR_RANGECOMPLETE               ((VL53L0X_DeviceError) 11)
+#define VL53L0X_DEVICEERROR_ALGOUNDERFLOW               ((VL53L0X_DeviceError) 12)
+#define VL53L0X_DEVICEERROR_ALGOOVERFLOW                ((VL53L0X_DeviceError) 13)
+#define VL53L0X_DEVICEERROR_RANGEIGNORETHRESHOLD        ((VL53L0X_DeviceError) 14)
+
+/** @} end of VL53L0X_DeviceError_group */
+
+
+/** @defgroup VL53L0X_CheckEnable_group Check Enable list
+ *  @brief Check Enable code
+ *
+ *  Define used to specify the LimitCheckId.
+ *  Use @a VL53L0X_GetLimitCheckInfo() to get the string.
+ *  @{
+ */
+
+#define VL53L0X_CHECKENABLE_SIGMA_FINAL_RANGE           0
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_FINAL_RANGE     1
+#define VL53L0X_CHECKENABLE_SIGNAL_REF_CLIP             2
+#define VL53L0X_CHECKENABLE_RANGE_IGNORE_THRESHOLD      3
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_MSRC            4
+#define VL53L0X_CHECKENABLE_SIGNAL_RATE_PRE_RANGE       5
+
+#define VL53L0X_CHECKENABLE_NUMBER_OF_CHECKS            6
+
+/** @}  end of VL53L0X_CheckEnable_group */
+
+
+/** @defgroup VL53L0X_GpioFunctionality_group Gpio Functionality
+ *  @brief Defines the different functionalities for the device GPIO(s)
+ *  @{
+ */
+typedef uint8_t VL53L0X_GpioFunctionality;
+
+#define VL53L0X_GPIOFUNCTIONALITY_OFF                     \
+	((VL53L0X_GpioFunctionality)  0) /*!< NO Interrupt  */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_LOW   \
+	((VL53L0X_GpioFunctionality)  1) /*!< Level Low (value < thresh_low)  */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_HIGH   \
+	((VL53L0X_GpioFunctionality)  2) /*!< Level High (value > thresh_high) */
+#define VL53L0X_GPIOFUNCTIONALITY_THRESHOLD_CROSSED_OUT    \
+	((VL53L0X_GpioFunctionality)  3)
+	/*!< Out Of Window (value < thresh_low OR value > thresh_high)  */
+#define VL53L0X_GPIOFUNCTIONALITY_NEW_MEASURE_READY        \
+	((VL53L0X_GpioFunctionality)  4) /*!< New Sample Ready  */
+
+/** @} end of VL53L0X_GpioFunctionality_group */
+
+
+/* Device register map */
+
+/** @defgroup VL53L0X_DefineRegisters_group Define Registers
+ *  @brief List of all the defined registers
+ *  @{
+ */
+#define VL53L0X_REG_SYSRANGE_START                        0x000
+	/** mask existing bit in #VL53L0X_REG_SYSRANGE_START*/
+	#define VL53L0X_REG_SYSRANGE_MODE_MASK          0x0F
+	/** bit 0 in #VL53L0X_REG_SYSRANGE_START write 1 toggle state in
+	 * continuous mode and arm next shot in single shot mode */
+	#define VL53L0X_REG_SYSRANGE_MODE_START_STOP    0x01
+	/** bit 1 write 0 in #VL53L0X_REG_SYSRANGE_START set single shot mode */
+	#define VL53L0X_REG_SYSRANGE_MODE_SINGLESHOT    0x00
+	/** bit 1 write 1 in #VL53L0X_REG_SYSRANGE_START set back-to-back
+	 *  operation mode */
+	#define VL53L0X_REG_SYSRANGE_MODE_BACKTOBACK    0x02
+	/** bit 2 write 1 in #VL53L0X_REG_SYSRANGE_START set timed operation
+	 *  mode */
+	#define VL53L0X_REG_SYSRANGE_MODE_TIMED         0x04
+	/** bit 3 write 1 in #VL53L0X_REG_SYSRANGE_START set histogram operation
+	 *  mode */
+	#define VL53L0X_REG_SYSRANGE_MODE_HISTOGRAM     0x08
+
+
+#define VL53L0X_REG_SYSTEM_THRESH_HIGH               0x000C
+#define VL53L0X_REG_SYSTEM_THRESH_LOW                0x000E
+
+
+#define VL53L0X_REG_SYSTEM_SEQUENCE_CONFIG		0x0001
+#define VL53L0X_REG_SYSTEM_RANGE_CONFIG			0x0009
+#define VL53L0X_REG_SYSTEM_INTERMEASUREMENT_PERIOD	0x0004
+
+
+#define VL53L0X_REG_SYSTEM_INTERRUPT_CONFIG_GPIO               0x000A
+	#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_DISABLED	0x00
+	#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_LOW	0x01
+	#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_LEVEL_HIGH	0x02
+	#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_OUT_OF_WINDOW	0x03
+	#define VL53L0X_REG_SYSTEM_INTERRUPT_GPIO_NEW_SAMPLE_READY	0x04
+
+#define VL53L0X_REG_GPIO_HV_MUX_ACTIVE_HIGH          0x0084
+
+
+#define VL53L0X_REG_SYSTEM_INTERRUPT_CLEAR           0x000B
+
+/* Result registers */
+#define VL53L0X_REG_RESULT_INTERRUPT_STATUS          0x0013
+#define VL53L0X_REG_RESULT_RANGE_STATUS              0x0014
+
+#define VL53L0X_REG_RESULT_CORE_PAGE  1
+#define VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_RTN   0x00BC
+#define VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_RTN    0x00C0
+#define VL53L0X_REG_RESULT_CORE_AMBIENT_WINDOW_EVENTS_REF   0x00D0
+#define VL53L0X_REG_RESULT_CORE_RANGING_TOTAL_EVENTS_REF    0x00D4
+#define VL53L0X_REG_RESULT_PEAK_SIGNAL_RATE_REF             0x00B6
+
+/* Algo register */
+
+#define VL53L0X_REG_ALGO_PART_TO_PART_RANGE_OFFSET_MM       0x0028
+
+#define VL53L0X_REG_I2C_SLAVE_DEVICE_ADDRESS                0x008a
+
+/* Check Limit registers */
+#define VL53L0X_REG_MSRC_CONFIG_CONTROL                     0x0060
+
+#define VL53L0X_REG_PRE_RANGE_CONFIG_MIN_SNR                      0X0027
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_LOW              0x0056
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VALID_PHASE_HIGH             0x0057
+#define VL53L0X_REG_PRE_RANGE_MIN_COUNT_RATE_RTN_LIMIT            0x0064
+
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_SNR                    0X0067
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_LOW            0x0047
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VALID_PHASE_HIGH           0x0048
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_MIN_COUNT_RATE_RTN_LIMIT   0x0044
+
+
+#define VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_HI              0X0061
+#define VL53L0X_REG_PRE_RANGE_CONFIG_SIGMA_THRESH_LO              0X0062
+
+/* PRE RANGE registers */
+#define VL53L0X_REG_PRE_RANGE_CONFIG_VCSEL_PERIOD                 0x0050
+#define VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_HI            0x0051
+#define VL53L0X_REG_PRE_RANGE_CONFIG_TIMEOUT_MACROP_LO            0x0052
+
+#define VL53L0X_REG_SYSTEM_HISTOGRAM_BIN                          0x0081
+#define VL53L0X_REG_HISTOGRAM_CONFIG_INITIAL_PHASE_SELECT         0x0033
+#define VL53L0X_REG_HISTOGRAM_CONFIG_READOUT_CTRL                 0x0055
+
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_VCSEL_PERIOD               0x0070
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_HI          0x0071
+#define VL53L0X_REG_FINAL_RANGE_CONFIG_TIMEOUT_MACROP_LO          0x0072
+#define VL53L0X_REG_CROSSTALK_COMPENSATION_PEAK_RATE_MCPS         0x0020
+
+#define VL53L0X_REG_MSRC_CONFIG_TIMEOUT_MACROP                    0x0046
+
+
+#define VL53L0X_REG_SOFT_RESET_GO2_SOFT_RESET_N	                 0x00bf
+#define VL53L0X_REG_IDENTIFICATION_MODEL_ID                       0x00c0
+#define VL53L0X_REG_IDENTIFICATION_REVISION_ID                    0x00c2
+
+#define VL53L0X_REG_OSC_CALIBRATE_VAL                             0x00f8
+
+
+#define VL53L0X_SIGMA_ESTIMATE_MAX_VALUE                          65535
+/* equivalent to a range sigma of 655.35mm */
+
+#define VL53L0X_REG_GLOBAL_CONFIG_VCSEL_WIDTH          0x032
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_0   0x0B0
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_1   0x0B1
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_2   0x0B2
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_3   0x0B3
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_4   0x0B4
+#define VL53L0X_REG_GLOBAL_CONFIG_SPAD_ENABLES_REF_5   0x0B5
+
+#define VL53L0X_REG_GLOBAL_CONFIG_REF_EN_START_SELECT   0xB6
+#define VL53L0X_REG_DYNAMIC_SPAD_NUM_REQUESTED_REF_SPAD 0x4E /* 0x14E */
+#define VL53L0X_REG_DYNAMIC_SPAD_REF_EN_START_OFFSET    0x4F /* 0x14F */
+#define VL53L0X_REG_POWER_MANAGEMENT_GO1_POWER_FORCE    0x80
+
+/*
+ * Speed of light in um per 1E-10 Seconds
+ */
+
+#define VL53L0X_SPEED_OF_LIGHT_IN_AIR 2997
+
+#define VL53L0X_REG_VHV_CONFIG_PAD_SCL_SDA__EXTSUP_HV     0x0089
+
+#define VL53L0X_REG_ALGO_PHASECAL_LIM                         0x0030 /* 0x130 */
+#define VL53L0X_REG_ALGO_PHASECAL_CONFIG_TIMEOUT              0x0030
+
+/** @} VL53L0X_DefineRegisters_group */
+
+/** @} VL53L0X_DevSpecDefines_group */
+
+
+#endif
+
+/* _VL53L0X_DEVICE_H_ */
+
+

3rd-part/Simple_VL53L0X/vl53l0x_i2c_platform.h

@@ -0,0 +1,404 @@
+/*
+ * COPYRIGHT (C) STMicroelectronics 2014. All rights reserved.
+ *
+ * This software is the confidential and proprietary information of
+ * STMicroelectronics ("Confidential Information").  You shall not
+ * disclose such Confidential Information and shall use it only in
+ * accordance with the terms of the license agreement you entered into
+ * with STMicroelectronics
+ *
+ * Programming Golden Rule: Keep it Simple!
+ *
+ */
+
+/**
+ * @file   VL53L0X_platform.h
+ * @brief  Function prototype definitions for Ewok Platform layer.
+ *
+ */
+
+
+#ifndef _VL53L0X_I2C_PLATFORM_H_
+#define _VL53L0X_I2C_PLATFORM_H_
+
+#include "vl53l0x_def.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+// Include uint8_t, unit16_t  etc definitions
+
+#include <stdint.h>
+#include <stdarg.h>
+
+
+/**
+ *  @brief Typedef defining .\n
+ * The developer shoud modify this to suit the platform being deployed.
+ *
+ */
+
+// enum  {TRUE = true, FALSE = false};
+
+/**
+ * @brief Typedef defining 8 bit unsigned char type.\n
+ * The developer shoud modify this to suit the platform being deployed.
+ *
+ */
+
+#ifndef bool_t
+typedef unsigned char bool_t;
+#endif
+
+
+#define	   I2C                0x01
+#define	   SPI                0x00
+
+#define    COMMS_BUFFER_SIZE    64  // MUST be the same size as the SV task buffer
+
+#define    BYTES_PER_WORD        2
+#define    BYTES_PER_DWORD       4
+
+#define    VL53L0X_MAX_STRING_LENGTH_PLT       256
+
+/**
+ * @brief  Initialise platform comms.
+ *
+ * @param  comms_type      - selects between I2C and SPI
+ * @param  comms_speed_khz - unsigned short containing the I2C speed in kHz
+ *
+ * @return status - status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_comms_initialise(uint8_t  comms_type,
+                                          uint16_t comms_speed_khz);
+
+/**
+ * @brief  Close platform comms.
+ *
+ * @return status - status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_comms_close(void);
+
+/**
+ * @brief  Cycle Power to Device
+ *
+ * @return status - status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_cycle_power(void);
+
+
+/**
+ * @brief Writes the supplied byte buffer to the device
+ *
+ * Wrapper for SystemVerilog Write Multi task
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t *spad_enables;
+ *
+ * int status = VL53L0X_write_multi(RET_SPAD_EN_0, spad_enables, 36);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  pdata - pointer to uint8_t buffer containing the data to be written
+ * @param  count - number of bytes in the supplied byte buffer
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_multi(uint8_t address, uint8_t index, uint8_t  *pdata, int32_t count);
+
+
+/**
+ * @brief  Reads the requested number of bytes from the device
+ *
+ * Wrapper for SystemVerilog Read Multi task
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t buffer[COMMS_BUFFER_SIZE];
+ *
+ * int status = status  = VL53L0X_read_multi(DEVICE_ID, buffer, 2)
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  pdata - pointer to the uint8_t buffer to store read data
+ * @param  count - number of uint8_t's to read
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_multi(uint8_t address,  uint8_t index, uint8_t  *pdata, int32_t count);
+
+
+/**
+ * @brief  Writes a single byte to the device
+ *
+ * Wrapper for SystemVerilog Write Byte task
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t page_number = MAIN_SELECT_PAGE;
+ *
+ * int status = VL53L0X_write_byte(PAGE_SELECT, page_number);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uint8_t data value to write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_byte(uint8_t address,  uint8_t index, uint8_t   data);
+
+
+/**
+ * @brief  Writes a single word (16-bit unsigned) to the device
+ *
+ * Manages the big-endian nature of the device (first byte written is the MS byte).
+ * Uses SystemVerilog Write Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint16_t nvm_ctrl_pulse_width = 0x0004;
+ *
+ * int status = VL53L0X_write_word(NVM_CTRL__PULSE_WIDTH_MSB, nvm_ctrl_pulse_width);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uin16_t data value write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_word(uint8_t address,  uint8_t index, uint16_t  data);
+
+
+/**
+ * @brief  Writes a single dword (32-bit unsigned) to the device
+ *
+ * Manages the big-endian nature of the device (first byte written is the MS byte).
+ * Uses SystemVerilog Write Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint32_t nvm_data = 0x0004;
+ *
+ * int status = VL53L0X_write_dword(NVM_CTRL__DATAIN_MMM, nvm_data);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  data  - uint32_t data value to write
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_write_dword(uint8_t address, uint8_t index, uint32_t  data);
+
+
+
+/**
+ * @brief  Reads a single byte from the device
+ *
+ * Uses SystemVerilog Read Byte task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint8_t device_status = 0;
+ *
+ * int status = VL53L0X_read_byte(STATUS, &device_status);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index  - uint8_t register index value
+ * @param  pdata  - pointer to uint8_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_byte(uint8_t address,  uint8_t index, uint8_t  *pdata);
+
+
+/**
+ * @brief  Reads a single word (16-bit unsigned) from the device
+ *
+ * Manages the big-endian nature of the device (first byte read is the MS byte).
+ * Uses SystemVerilog Read Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint16_t timeout = 0;
+ *
+ * int status = VL53L0X_read_word(TIMEOUT_OVERALL_PERIODS_MSB, &timeout);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index  - uint8_t register index value
+ * @param  pdata  - pointer to uint16_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_word(uint8_t address,  uint8_t index, uint16_t *pdata);
+
+
+/**
+ * @brief  Reads a single dword (32-bit unsigned) from the device
+ *
+ * Manages the big-endian nature of the device (first byte read is the MS byte).
+ * Uses SystemVerilog Read Multi task.
+ *
+ * @code
+ *
+ * Example:
+ *
+ * uint32_t range_1 = 0;
+ *
+ * int status = VL53L0X_read_dword(RANGE_1_MMM, &range_1);
+ *
+ * @endcode
+ *
+ * @param  address - uint8_t device address value
+ * @param  index - uint8_t register index value
+ * @param  pdata - pointer to uint32_t data value
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_read_dword(uint8_t address, uint8_t index, uint32_t *pdata);
+
+
+/**
+ * @brief  Implements a programmable wait in us
+ *
+ * Wrapper for SystemVerilog Wait in micro seconds task
+ *
+ * @param  wait_us - integer wait in micro seconds
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_platform_wait_us(int32_t wait_us);
+
+
+/**
+ * @brief  Implements a programmable wait in ms
+ *
+ * Wrapper for SystemVerilog Wait in milli seconds task
+ *
+ * @param  wait_ms - integer wait in milli seconds
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_wait_ms(int32_t wait_ms);
+
+
+/**
+ * @brief Set GPIO value
+ *
+ * @param  level  - input  level - either 0 or 1
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_set_gpio(uint8_t  level);
+
+
+/**
+ * @brief Get GPIO value
+ *
+ * @param  plevel - uint8_t pointer to store GPIO level (0 or 1)
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_get_gpio(uint8_t *plevel);
+
+/**
+ * @brief Release force on GPIO
+ *
+ * @return status - SystemVerilog status 0 = ok, 1 = error
+ *
+ */
+
+int32_t VL53L0X_release_gpio(void);
+
+
+/**
+* @brief Get the frequency of the timer used for ranging results time stamps
+*
+* @param[out] ptimer_freq_hz : pointer for timer frequency
+*
+* @return status : 0 = ok, 1 = error
+*
+*/
+
+int32_t VL53L0X_get_timer_frequency(int32_t *ptimer_freq_hz);
+
+/**
+* @brief Get the timer value in units of timer_freq_hz (see VL53L0X_get_timestamp_frequency())
+*
+* @param[out] ptimer_count : pointer for timer count value
+*
+* @return status : 0 = ok, 1 = error
+*
+*/
+
+int32_t VL53L0X_get_timer_value(int32_t *ptimer_count);
+
+
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif //_VL53L0X_I2C_PLATFORM_H_
+

3rd-part/Simple_VL53L0X/vl53l0x_interrupt_threshold_settings.h

@@ -0,0 +1,194 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of STMicroelectronics nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+
+#ifndef _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_
+#define _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+uint8_t InterruptThresholdSettings[] = {
+
+	/* Start of Interrupt Threshold Settings */
+	0x1, 0xff, 0x00,
+	0x1, 0x80, 0x01,
+	0x1, 0xff, 0x01,
+	0x1, 0x00, 0x00,
+	0x1, 0xff, 0x01,
+	0x1, 0x4f, 0x02,
+	0x1, 0xFF, 0x0E,
+	0x1, 0x00, 0x03,
+	0x1, 0x01, 0x84,
+	0x1, 0x02, 0x0A,
+	0x1, 0x03, 0x03,
+	0x1, 0x04, 0x08,
+	0x1, 0x05, 0xC8,
+	0x1, 0x06, 0x03,
+	0x1, 0x07, 0x8D,
+	0x1, 0x08, 0x08,
+	0x1, 0x09, 0xC6,
+	0x1, 0x0A, 0x01,
+	0x1, 0x0B, 0x02,
+	0x1, 0x0C, 0x00,
+	0x1, 0x0D, 0xD5,
+	0x1, 0x0E, 0x18,
+	0x1, 0x0F, 0x12,
+	0x1, 0x10, 0x01,
+	0x1, 0x11, 0x82,
+	0x1, 0x12, 0x00,
+	0x1, 0x13, 0xD5,
+	0x1, 0x14, 0x18,
+	0x1, 0x15, 0x13,
+	0x1, 0x16, 0x03,
+	0x1, 0x17, 0x86,
+	0x1, 0x18, 0x0A,
+	0x1, 0x19, 0x09,
+	0x1, 0x1A, 0x08,
+	0x1, 0x1B, 0xC2,
+	0x1, 0x1C, 0x03,
+	0x1, 0x1D, 0x8F,
+	0x1, 0x1E, 0x0A,
+	0x1, 0x1F, 0x06,
+	0x1, 0x20, 0x01,
+	0x1, 0x21, 0x02,
+	0x1, 0x22, 0x00,
+	0x1, 0x23, 0xD5,
+	0x1, 0x24, 0x18,
+	0x1, 0x25, 0x22,
+	0x1, 0x26, 0x01,
+	0x1, 0x27, 0x82,
+	0x1, 0x28, 0x00,
+	0x1, 0x29, 0xD5,
+	0x1, 0x2A, 0x18,
+	0x1, 0x2B, 0x0B,
+	0x1, 0x2C, 0x28,
+	0x1, 0x2D, 0x78,
+	0x1, 0x2E, 0x28,
+	0x1, 0x2F, 0x91,
+	0x1, 0x30, 0x00,
+	0x1, 0x31, 0x0B,
+	0x1, 0x32, 0x00,
+	0x1, 0x33, 0x0B,
+	0x1, 0x34, 0x00,
+	0x1, 0x35, 0xA1,
+	0x1, 0x36, 0x00,
+	0x1, 0x37, 0xA0,
+	0x1, 0x38, 0x00,
+	0x1, 0x39, 0x04,
+	0x1, 0x3A, 0x28,
+	0x1, 0x3B, 0x30,
+	0x1, 0x3C, 0x0C,
+	0x1, 0x3D, 0x04,
+	0x1, 0x3E, 0x0F,
+	0x1, 0x3F, 0x79,
+	0x1, 0x40, 0x28,
+	0x1, 0x41, 0x1E,
+	0x1, 0x42, 0x2F,
+	0x1, 0x43, 0x87,
+	0x1, 0x44, 0x00,
+	0x1, 0x45, 0x0B,
+	0x1, 0x46, 0x00,
+	0x1, 0x47, 0x0B,
+	0x1, 0x48, 0x00,
+	0x1, 0x49, 0xA7,
+	0x1, 0x4A, 0x00,
+	0x1, 0x4B, 0xA6,
+	0x1, 0x4C, 0x00,
+	0x1, 0x4D, 0x04,
+	0x1, 0x4E, 0x01,
+	0x1, 0x4F, 0x00,
+	0x1, 0x50, 0x00,
+	0x1, 0x51, 0x80,
+	0x1, 0x52, 0x09,
+	0x1, 0x53, 0x08,
+	0x1, 0x54, 0x01,
+	0x1, 0x55, 0x00,
+	0x1, 0x56, 0x0F,
+	0x1, 0x57, 0x79,
+	0x1, 0x58, 0x09,
+	0x1, 0x59, 0x05,
+	0x1, 0x5A, 0x00,
+	0x1, 0x5B, 0x60,
+	0x1, 0x5C, 0x05,
+	0x1, 0x5D, 0xD1,
+	0x1, 0x5E, 0x0C,
+	0x1, 0x5F, 0x3C,
+	0x1, 0x60, 0x00,
+	0x1, 0x61, 0xD0,
+	0x1, 0x62, 0x0B,
+	0x1, 0x63, 0x03,
+	0x1, 0x64, 0x28,
+	0x1, 0x65, 0x10,
+	0x1, 0x66, 0x2A,
+	0x1, 0x67, 0x39,
+	0x1, 0x68, 0x0B,
+	0x1, 0x69, 0x02,
+	0x1, 0x6A, 0x28,
+	0x1, 0x6B, 0x10,
+	0x1, 0x6C, 0x2A,
+	0x1, 0x6D, 0x61,
+	0x1, 0x6E, 0x0C,
+	0x1, 0x6F, 0x00,
+	0x1, 0x70, 0x0F,
+	0x1, 0x71, 0x79,
+	0x1, 0x72, 0x00,
+	0x1, 0x73, 0x0B,
+	0x1, 0x74, 0x00,
+	0x1, 0x75, 0x0B,
+	0x1, 0x76, 0x00,
+	0x1, 0x77, 0xA1,
+	0x1, 0x78, 0x00,
+	0x1, 0x79, 0xA0,
+	0x1, 0x7A, 0x00,
+	0x1, 0x7B, 0x04,
+	0x1, 0xFF, 0x04,
+	0x1, 0x79, 0x1D,
+	0x1, 0x7B, 0x27,
+	0x1, 0x96, 0x0E,
+	0x1, 0x97, 0xFE,
+	0x1, 0x98, 0x03,
+	0x1, 0x99, 0xEF,
+	0x1, 0x9A, 0x02,
+	0x1, 0x9B, 0x44,
+	0x1, 0x73, 0x07,
+	0x1, 0x70, 0x01,
+	0x1, 0xff, 0x01,
+	0x1, 0x00, 0x01,
+	0x1, 0xff, 0x00,
+	0x00, 0x00, 0x00
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_INTERRUPT_THRESHOLD_SETTINGS_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_platform.h

@@ -0,0 +1,240 @@
+/*******************************************************************************
+Copyright <20> 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+
+
+#ifndef _VL53L0X_PLATFORM_H_
+#define _VL53L0X_PLATFORM_H_
+
+#include "vl53l0x_def.h"
+#include "vl53l0x_platform_log.h"
+#include "vl53l0x_i2c_platform.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file vl53l0x_platform.h
+ *
+ * @brief All end user OS/platform/application porting
+ */
+
+/**
+ * @defgroup VL53L0X_platform_group VL53L0X Platform Functions
+ * @brief    VL53L0X Platform Functions
+ *  @{
+ */
+
+/**
+ * @struct  VL53L0X_Dev_t
+ * @brief    Generic PAL device type that does link between API and platform abstraction layer
+ *
+ */
+typedef struct {
+    VL53L0X_DevData_t Data;               /*!< embed ST Ewok Dev  data as "Data"*/
+
+    /*!< user specific field */
+    uint8_t   I2cDevAddr;                /*!< i2c device address user specific field */
+    uint8_t   comms_type;                /*!< Type of comms : VL53L0X_COMMS_I2C or VL53L0X_COMMS_SPI */
+    uint16_t  comms_speed_khz;           /*!< Comms speed [kHz] : typically 400kHz for I2C           */
+
+} VL53L0X_Dev_t;
+
+
+/**
+ * @brief   Declare the device Handle as a pointer of the structure @a VL53L0X_Dev_t.
+ *
+ */
+typedef VL53L0X_Dev_t* VL53L0X_DEV;
+
+/**
+ * @def PALDevDataGet
+ * @brief Get ST private structure @a VL53L0X_DevData_t data access
+ *
+ * @param Dev       Device Handle
+ * @param field     ST structure field name
+ * It maybe used and as real data "ref" not just as "get" for sub-structure item
+ * like PALDevDataGet(FilterData.field)[i] or PALDevDataGet(FilterData.MeasurementIndex)++
+ */
+#define PALDevDataGet(Dev, field) (Dev->Data.field)
+
+/**
+ * @def PALDevDataSet(Dev, field, data)
+ * @brief  Set ST private structure @a VL53L0X_DevData_t data field
+ * @param Dev       Device Handle
+ * @param field     ST structure field name
+ * @param data      Data to be set
+ */
+#define PALDevDataSet(Dev, field, data) (Dev->Data.field)=(data)
+
+
+/**
+ * @defgroup VL53L0X_registerAccess_group PAL Register Access Functions
+ * @brief    PAL Register Access Functions
+ *  @{
+ */
+
+/**
+ * Lock comms interface to serialize all commands to a shared I2C interface for a specific device
+ * @param   Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_LockSequenceAccess(VL53L0X_DEV Dev);
+
+/**
+ * Unlock comms interface to serialize all commands to a shared I2C interface for a specific device
+ * @param   Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_UnlockSequenceAccess(VL53L0X_DEV Dev);
+
+
+/**
+ * Writes the supplied byte buffer to the device
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   pdata     Pointer to uint8_t buffer containing the data to be written
+ * @param   count     Number of bytes in the supplied byte buffer
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WriteMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
+
+/**
+ * Reads the requested number of bytes from the device
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   pdata     Pointer to the uint8_t buffer to store read data
+ * @param   count     Number of uint8_t's to read
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_ReadMulti(VL53L0X_DEV Dev, uint8_t index, uint8_t *pdata, uint32_t count);
+
+/**
+ * Write single byte register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      8 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrByte(VL53L0X_DEV Dev, uint8_t index, uint8_t data);
+
+/**
+ * Write word register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      16 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrWord(VL53L0X_DEV Dev, uint8_t index, uint16_t data);
+
+/**
+ * Write double word (4 byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      32 bit register data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_WrDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t data);
+
+/**
+ * Read single byte register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 8 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdByte(VL53L0X_DEV Dev, uint8_t index, uint8_t *data);
+
+/**
+ * Read word (2byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 16 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdWord(VL53L0X_DEV Dev, uint8_t index, uint16_t *data);
+
+/**
+ * Read dword (4byte) register
+ * @param   Dev       Device Handle
+ * @param   index     The register index
+ * @param   data      pointer to 32 bit data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_RdDWord(VL53L0X_DEV Dev, uint8_t index, uint32_t *data);
+
+/**
+ * Threat safe Update (read/modify/write) single byte register
+ *
+ * Final_reg = (Initial_reg & and_data) |or_data
+ *
+ * @param   Dev        Device Handle
+ * @param   index      The register index
+ * @param   AndData    8 bit and data
+ * @param   OrData     8 bit or data
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_UpdateByte(VL53L0X_DEV Dev, uint8_t index, uint8_t AndData, uint8_t OrData);
+
+/** @} end of VL53L0X_registerAccess_group */
+
+
+/**
+ * @brief execute delay in all polling API call
+ *
+ * A typical multi-thread or RTOs implementation is to sleep the task for some 5ms (with 100Hz max rate faster polling is not needed)
+ * if nothing specific is need you can define it as an empty/void macro
+ * @code
+ * #define VL53L0X_PollingDelay(...) (void)0
+ * @endcode
+ * @param Dev       Device Handle
+ * @return  VL53L0X_ERROR_NONE        Success
+ * @return  "Other error code"    See ::VL53L0X_Error
+ */
+VL53L0X_Error VL53L0X_PollingDelay(VL53L0X_DEV Dev); /* usually best implemented as a real function */
+/** @} end of VL53L0X_platform_group */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _VL53L0X_PLATFORM_H_ */
+
+
+

3rd-part/Simple_VL53L0X/vl53l0x_platform_log.h

@@ -0,0 +1,118 @@
+/*******************************************************************************
+Copyright <20> 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+
+
+#ifndef _VL53L0X_PLATFORM_LOG_H_
+#define _VL53L0X_PLATFORM_LOG_H_
+
+#include <stdio.h>
+#include <string.h>
+/* LOG Functions */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @file vl53l0x_platform_log.h
+ *
+ * @brief platform log function definition
+ */
+
+//#define VL53L0X_LOG_ENABLE 0
+
+enum {
+    TRACE_LEVEL_NONE,
+    TRACE_LEVEL_ERRORS,
+    TRACE_LEVEL_WARNING,
+    TRACE_LEVEL_INFO,
+    TRACE_LEVEL_DEBUG,
+    TRACE_LEVEL_ALL,
+    TRACE_LEVEL_IGNORE
+};
+
+enum {
+    TRACE_FUNCTION_NONE = 0,
+    TRACE_FUNCTION_I2C  = 1,
+    TRACE_FUNCTION_ALL  = 0x7fffffff //all bits except sign
+};
+
+enum {
+    TRACE_MODULE_NONE              = 0x0,
+    TRACE_MODULE_API               = 0x1,
+    TRACE_MODULE_PLATFORM          = 0x2,
+    TRACE_MODULE_ALL               = 0x7fffffff //all bits except sign
+};
+
+
+#ifdef VL53L0X_LOG_ENABLE
+
+#include <sys/time.h>
+
+extern uint32_t _trace_level;
+
+
+
+int32_t VL53L0X_trace_config(char *filename, uint32_t modules, uint32_t level, uint32_t functions);
+
+void trace_print_module_function(uint32_t module, uint32_t level, uint32_t function, const char *format, ...);
+
+
+//extern FILE * log_file;
+
+#define LOG_GET_TIME() (int)clock()
+
+#define _LOG_FUNCTION_START(module, fmt, ... ) \
+        trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL, "%ld <START> %s "fmt"\n", LOG_GET_TIME(), __FUNCTION__, ##__VA_ARGS__);
+
+#define _LOG_FUNCTION_END(module, status, ... )\
+        trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL, "%ld <END> %s %d\n", LOG_GET_TIME(), __FUNCTION__, (int)status, ##__VA_ARGS__)
+
+#define _LOG_FUNCTION_END_FMT(module, status, fmt, ... )\
+        trace_print_module_function(module, _trace_level, TRACE_FUNCTION_ALL, "%ld <END> %s %d "fmt"\n", LOG_GET_TIME(),  __FUNCTION__, (int)status,##__VA_ARGS__)
+
+// __func__ is gcc only
+//#define VL53L0X_ErrLog( fmt, ...)  fprintf(stderr, "VL53L0X_ErrLog %s" fmt "\n", __func__, ##__VA_ARGS__)
+
+#else /* VL53L0X_LOG_ENABLE no logging */
+    #define VL53L0X_ErrLog(...) (void)0
+    #define _LOG_FUNCTION_START(module, fmt, ... ) (void)0
+    #define _LOG_FUNCTION_END(module, status, ... ) (void)0
+    #define _LOG_FUNCTION_END_FMT(module, status, fmt, ... ) (void)0
+#endif /* else */
+
+#define VL53L0X_COPYSTRING(str, ...) strcpy(str, ##__VA_ARGS__)
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* _VL53L0X_PLATFORM_LOG_H_ */
+
+
+

3rd-part/Simple_VL53L0X/vl53l0x_tuning.h

@@ -0,0 +1,146 @@
+/*******************************************************************************
+Copyright <20> 2016, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+	* Redistributions of source code must retain the above copyright
+	  notice, this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright
+	  notice, this list of conditions and the following disclaimer in the
+	  documentation and/or other materials provided with the distribution.
+	* Neither the name of STMicroelectronics nor the
+	  names of its contributors may be used to endorse or promote products
+	  derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*******************************************************************************/
+
+
+#ifndef _VL53L0X_TUNING_H_
+#define _VL53L0X_TUNING_H_
+
+#include "vl53l0x_def.h"
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+uint8_t DefaultTuningSettings[] = {
+
+	/* update 02/11/2015_v36 */
+	0x01, 0xFF, 0x01,
+	0x01, 0x00, 0x00,
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x09, 0x00,
+	0x01, 0x10, 0x00,
+	0x01, 0x11, 0x00,
+
+	0x01, 0x24, 0x01,
+	0x01, 0x25, 0xff,
+	0x01, 0x75, 0x00,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x4e, 0x2c,
+	0x01, 0x48, 0x00,
+	0x01, 0x30, 0x20,
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x30, 0x09, /* mja changed from 0x64. */
+	0x01, 0x54, 0x00,
+	0x01, 0x31, 0x04,
+	0x01, 0x32, 0x03,
+	0x01, 0x40, 0x83,
+	0x01, 0x46, 0x25,
+	0x01, 0x60, 0x00,
+	0x01, 0x27, 0x00,
+	0x01, 0x50, 0x06,
+	0x01, 0x51, 0x00,
+	0x01, 0x52, 0x96,
+	0x01, 0x56, 0x08,
+	0x01, 0x57, 0x30,
+	0x01, 0x61, 0x00,
+	0x01, 0x62, 0x00,
+	0x01, 0x64, 0x00,
+	0x01, 0x65, 0x00,
+	0x01, 0x66, 0xa0,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x22, 0x32,
+	0x01, 0x47, 0x14,
+	0x01, 0x49, 0xff,
+	0x01, 0x4a, 0x00,
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x7a, 0x0a,
+	0x01, 0x7b, 0x00,
+	0x01, 0x78, 0x21,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x23, 0x34,
+	0x01, 0x42, 0x00,
+	0x01, 0x44, 0xff,
+	0x01, 0x45, 0x26,
+	0x01, 0x46, 0x05,
+	0x01, 0x40, 0x40,
+	0x01, 0x0E, 0x06,
+	0x01, 0x20, 0x1a,
+	0x01, 0x43, 0x40,
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x34, 0x03,
+	0x01, 0x35, 0x44,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x31, 0x04,
+	0x01, 0x4b, 0x09,
+	0x01, 0x4c, 0x05,
+	0x01, 0x4d, 0x04,
+
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x44, 0x00,
+	0x01, 0x45, 0x20,
+	0x01, 0x47, 0x08,
+	0x01, 0x48, 0x28,
+	0x01, 0x67, 0x00,
+	0x01, 0x70, 0x04,
+	0x01, 0x71, 0x01,
+	0x01, 0x72, 0xfe,
+	0x01, 0x76, 0x00,
+	0x01, 0x77, 0x00,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x0d, 0x01,
+
+	0x01, 0xFF, 0x00,
+	0x01, 0x80, 0x01,
+	0x01, 0x01, 0xF8,
+
+	0x01, 0xFF, 0x01,
+	0x01, 0x8e, 0x01,
+	0x01, 0x00, 0x01,
+	0x01, 0xFF, 0x00,
+	0x01, 0x80, 0x00,
+
+	0x00, 0x00, 0x00
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _VL53L0X_TUNING_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_types.h

@@ -0,0 +1,111 @@
+/*******************************************************************************
+Copyright <20> 2015, STMicroelectronics International N.V.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of STMicroelectronics nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND
+NON-INFRINGEMENT OF INTELLECTUAL PROPERTY RIGHTS ARE DISCLAIMED.
+IN NO EVENT SHALL STMICROELECTRONICS INTERNATIONAL N.V. BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+********************************************************************************/
+/**
+ * @file  vl53l0x_types.h
+ * @brief VL53L0X types definition
+ */
+
+#ifndef VL53L0X_TYPES_H_
+#define VL53L0X_TYPES_H_
+
+/** @defgroup porting_type  Basic type definition
+ *  @ingroup  VL53L0X_platform_group
+ *
+ *  @brief  file vl53l0x_types.h files hold basic type definition that may requires porting
+ *
+ *  contains type that must be defined for the platform\n
+ *  when target platform and compiler provide stdint.h and stddef.h it is enough to include it.\n
+ *  If stdint.h is not available review and adapt all signed and unsigned 8/16/32 bits basic types. \n
+ *  If stddef.h is not available review and adapt NULL definition .
+ */
+#include <stdint.h>
+#include <stddef.h>
+
+#ifndef NULL
+#error "Error NULL definition should be done. Please add required include "
+#endif
+
+
+#if ! defined(STDINT_H) &&  !defined(_GCC_STDINT_H) &&!defined(__STDINT_DECLS) && !defined(_GCC_WRAP_STDINT_H)
+
+ #pragma message("Please review  type definition of STDINT define for your platform and add to list above ")
+
+ /*
+  *  target platform do not provide stdint or use a different #define than above
+  *  to avoid seeing the message below addapt the #define list above or implement
+  *  all type and delete these pragma
+  */
+
+/** \ingroup VL53L0X_portingType_group
+ * @{
+ */
+
+
+typedef unsigned long long uint64_t;
+
+
+/** @brief Typedef defining 32 bit unsigned int type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned int uint32_t;
+
+/** @brief Typedef defining 32 bit int type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef int int32_t;
+
+/** @brief Typedef defining 16 bit unsigned short type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned short uint16_t;
+
+/** @brief Typedef defining 16 bit short type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef short int16_t;
+
+/** @brief Typedef defining 8 bit unsigned char type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef unsigned char uint8_t;
+
+/** @brief Typedef defining 8 bit char type.\n
+ * The developer should modify this to suit the platform being deployed.
+ */
+typedef signed char int8_t;
+
+/** @}  */
+#endif /* _STDINT_H */
+
+
+/** use where fractional values are expected
+ *
+ * Given a floating point value f it's .16 bit point is (int)(f*(1<<16))*/
+typedef uint32_t FixPoint1616_t;
+
+#endif /* VL53L0X_TYPES_H_ */

3rd-part/Simple_VL53L0X/vl53l0x_wmd_api.h

@@ -0,0 +1,30 @@
+/** 
+* @brief        激光传感器导出的API函数
+* @details  		因为现在的需求和本身能力 追求简单化只输出了两个函数 一个是初始化 一个就是读取值 
+* @author      	WMD
+* @date     		2018年4月22日23:26:22 
+* @version  		1.1
+* @par Copyright (c):  
+*       WMD 
+* @par 日志
+*/  
+#ifndef _VL53L0X_WMD_API_H
+#define _VL53L0X_WMD_API_H
+
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+	
+//!传感器初始化
+void VL53L0X_Init(void);
+
+//!获得距离值
+unsigned short int VL53L0X_GetValue(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

3rd-part/lwprintf/.gitignore

@@ -0,0 +1,400 @@
+#Build Keil files
+*.rar
+*.o
+*.d
+*.crf
+*.htm
+*.dep
+*.map
+*.bak
+*.axf
+*.lnp
+*.lst
+*.ini
+*.scvd
+*.iex
+*.sct
+*.MajerleT
+*.tjuln
+*.tilen
+*.dbgconf
+*.uvguix
+*.uvoptx
+*.__i
+*.i
+*.txt
+!docs/*.txt
+!CMakeLists.txt
+RTE/
+
+*debug
+
+# IAR Settings
+**/settings/*.crun
+**/settings/*.dbgdt
+**/settings/*.cspy
+**/settings/*.cspy.*
+**/settings/*.xcl
+**/settings/*.dni
+**/settings/*.wsdt
+**/settings/*.wspos
+
+# IAR Debug Exe
+**/Exe/*.sim
+
+# IAR Debug Obj
+**/Obj/*.pbd
+**/Obj/*.pbd.*
+**/Obj/*.pbi
+**/Obj/*.pbi.*
+
+*.TMP
+/docs_src/x_Doxyfile.doxy
+
+.DS_Store
+
+## Ignore Visual Studio temporary files, build results, and
+## files generated by popular Visual Studio add-ons.
+##
+## Get latest from https://github.com/github/gitignore/blob/master/VisualStudio.gitignore
+
+# User-specific files
+*.suo
+*.user
+*.userosscache
+*.sln.docstates
+
+# User-specific files (MonoDevelop/Xamarin Studio)
+*.userprefs
+
+# Build results
+[Dd]ebug/
+[Dd]ebugPublic/
+[Rr]elease/
+[Rr]eleases/
+[Dd]ebug*/
+x64/
+x86/
+bld/
+[Bb]in/
+[Oo]bj/
+[Ll]og/
+_build/
+build/
+
+# Visual Studio 2015/2017 cache/options directory
+.vs/
+# Uncomment if you have tasks that create the project's static files in wwwroot
+#wwwroot/
+
+# Visual Studio 2017 auto generated files
+Generated\ Files/
+
+# MSTest test Results
+[Tt]est[Rr]esult*/
+[Bb]uild[Ll]og.*
+
+# NUNIT
+*.VisualState.xml
+TestResult.xml
+
+# Build Results of an ATL Project
+[Dd]ebugPS/
+[Rr]eleasePS/
+dlldata.c
+
+# Benchmark Results
+BenchmarkDotNet.Artifacts/
+
+# .NET Core
+project.lock.json
+project.fragment.lock.json
+artifacts/
+**/Properties/launchSettings.json
+
+# StyleCop
+StyleCopReport.xml
+
+# Files built by Visual Studio
+*_i.c
+*_p.c
+*_i.h
+*.ilk
+*.meta
+*.obj
+*.pch
+*.pdb
+*.pgc
+*.pgd
+*.rsp
+*.sbr
+*.tlb
+*.tli
+*.tlh
+*.tmp
+*.tmp_proj
+*.log
+*.vspscc
+*.vssscc
+.builds
+*.pidb
+*.svclog
+*.scc
+*.out
+*.sim
+
+# Chutzpah Test files
+_Chutzpah*
+
+# Visual C++ cache files
+ipch/
+*.aps
+*.ncb
+*.opendb
+*.opensdf
+*.sdf
+*.cachefile
+*.VC.db
+*.VC.VC.opendb
+
+# Visual Studio profiler
+*.psess
+*.vsp
+*.vspx
+*.sap
+
+# Visual Studio Trace Files
+*.e2e
+
+# TFS 2012 Local Workspace
+$tf/
+
+# Guidance Automation Toolkit
+*.gpState
+
+# ReSharper is a .NET coding add-in
+_ReSharper*/
+*.[Rr]e[Ss]harper
+*.DotSettings.user
+
+# JustCode is a .NET coding add-in
+.JustCode
+
+# TeamCity is a build add-in
+_TeamCity*
+
+# DotCover is a Code Coverage Tool
+*.dotCover
+
+# AxoCover is a Code Coverage Tool
+.axoCover/*
+!.axoCover/settings.json
+
+# Visual Studio code coverage results
+*.coverage
+*.coveragexml
+
+# NCrunch
+_NCrunch_*
+.*crunch*.local.xml
+nCrunchTemp_*
+
+# MightyMoose
+*.mm.*
+AutoTest.Net/
+
+# Web workbench (sass)
+.sass-cache/
+
+# Installshield output folder
+[Ee]xpress/
+
+# DocProject is a documentation generator add-in
+DocProject/buildhelp/
+DocProject/Help/*.HxT
+DocProject/Help/*.HxC
+DocProject/Help/*.hhc
+DocProject/Help/*.hhk
+DocProject/Help/*.hhp
+DocProject/Help/Html2
+DocProject/Help/html
+
+# Click-Once directory
+publish/
+
+# Publish Web Output
+*.[Pp]ublish.xml
+*.azurePubxml
+# Note: Comment the next line if you want to checkin your web deploy settings,
+# but database connection strings (with potential passwords) will be unencrypted
+*.pubxml
+*.publishproj
+
+# Microsoft Azure Web App publish settings. Comment the next line if you want to
+# checkin your Azure Web App publish settings, but sensitive information contained
+# in these scripts will be unencrypted
+PublishScripts/
+
+# NuGet Packages
+*.nupkg
+# The packages folder can be ignored because of Package Restore
+**/[Pp]ackages/*
+# except build/, which is used as an MSBuild target.
+!**/[Pp]ackages/build/
+# Uncomment if necessary however generally it will be regenerated when needed
+#!**/[Pp]ackages/repositories.config
+# NuGet v3's project.json files produces more ignorable files
+*.nuget.props
+*.nuget.targets
+
+# Microsoft Azure Build Output
+csx/
+*.build.csdef
+
+# Microsoft Azure Emulator
+ecf/
+rcf/
+
+# Windows Store app package directories and files
+AppPackages/
+BundleArtifacts/
+Package.StoreAssociation.xml
+_pkginfo.txt
+*.appx
+
+# Visual Studio cache files
+# files ending in .cache can be ignored
+*.[Cc]ache
+# but keep track of directories ending in .cache
+!*.[Cc]ache/
+
+# Others
+ClientBin/
+~$*
+*~
+*.dbmdl
+*.dbproj.schemaview
+*.jfm
+*.pfx
+*.publishsettings
+orleans.codegen.cs
+
+# Including strong name files can present a security risk
+# (https://github.com/github/gitignore/pull/2483#issue-259490424)
+#*.snk
+
+# Since there are multiple workflows, uncomment next line to ignore bower_components
+# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622)
+#bower_components/
+
+# RIA/Silverlight projects
+Generated_Code/
+
+# Backup & report files from converting an old project file
+# to a newer Visual Studio version. Backup files are not needed,
+# because we have git ;-)
+_UpgradeReport_Files/
+Backup*/
+UpgradeLog*.XML
+UpgradeLog*.htm
+
+# SQL Server files
+*.mdf
+*.ldf
+*.ndf
+
+# Business Intelligence projects
+*.rdl.data
+*.bim.layout
+*.bim_*.settings
+
+# Microsoft Fakes
+FakesAssemblies/
+
+# GhostDoc plugin setting file
+*.GhostDoc.xml
+
+# Node.js Tools for Visual Studio
+.ntvs_analysis.dat
+node_modules/
+
+# TypeScript v1 declaration files
+typings/
+
+# Visual Studio 6 build log
+*.plg
+
+# Visual Studio 6 workspace options file
+*.opt
+
+# Visual Studio 6 auto-generated workspace file (contains which files were open etc.)
+*.vbw
+
+# Visual Studio LightSwitch build output
+**/*.HTMLClient/GeneratedArtifacts
+**/*.DesktopClient/GeneratedArtifacts
+**/*.DesktopClient/ModelManifest.xml
+**/*.Server/GeneratedArtifacts
+**/*.Server/ModelManifest.xml
+_Pvt_Extensions
+
+# Paket dependency manager
+.paket/paket.exe
+paket-files/
+
+# FAKE - F# Make
+.fake/
+
+# JetBrains Rider
+.idea/
+*.sln.iml
+
+# CodeRush
+.cr/
+
+# Python Tools for Visual Studio (PTVS)
+__pycache__/
+*.pyc
+
+# Cake - Uncomment if you are using it
+# tools/**
+# !tools/packages.config
+
+# Tabs Studio
+*.tss
+
+# Telerik's JustMock configuration file
+*.jmconfig
+
+# BizTalk build output
+*.btp.cs
+*.btm.cs
+*.odx.cs
+*.xsd.cs
+
+# OpenCover UI analysis results
+OpenCover/
+
+# Azure Stream Analytics local run output
+ASALocalRun/
+
+# MSBuild Binary and Structured Log
+*.binlog
+
+log_file.txt
+.metadata/
+.mxproject
+.settings/
+project.ioc
+mx.scratch
+*.tilen majerle
+
+
+# Altium
+Project outputs*
+History/
+*.SchDocPreview
+*.$$$Preview
+
+# VSCode projects
+project_vscode_compiled.exe

3rd-part/lwprintf/AUTHORS

@@ -0,0 +1,6 @@
+Tilen Majerle <tilen.majerle@gmail.com>
+Tilen Majerle <tilen@majerle.eu>
+Okarss <104319900+Okarss@users.noreply.github.com>
+Dmitry Karasev <karasevsdmitry@yandex.ru>
+Brian <bayuan@purdue.edu>
+Peter Maxwell Warasila <madmaxwell@soundcomesout.com>

3rd-part/lwprintf/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+
+## Develop
+
+- Add `lwprintf_debug` and `lwprintf_debug_cond` functions
+
+## v1.0.5
+
+- Fix building the library with `LWPRINTF_CFG_OS=1` and `LWPRINTF_CFG_OS_MANUAL_PROTECT=0` options
+
+## v1.0.4
+
+- Fix calculation for NULL terminated string and precision with 0 as an input
+- Split CMakeLists.txt files between library and executable
+- Fix missing break in switch statement
+- Add support for manual mutual-exclusion setup in OS mode
+- Change license year to 2022
+- Update code style with astyle
+- Add `.clang-format` draft
+- Fix protection functions for when print mode is not used
+
+## v1.0.3
+
+- CMSIS-OS improvements for Kernel aware debuggers
+
+## v1.0.2
+
+- Fixed `float` output when engineering mode is disabled
+
+## v1.0.1
+
+- Fixed compiler error when engineering mode disabled but float enabled
+- Properly handled `zero` float inputs
+
+## v1.0.0
+
+- First stable release
+- Embedded systems optimized library
+- Apply all modifiers except `%a`
+- Extensive docs available
+- Operating system ready with CMSIS-OS template

3rd-part/lwprintf/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Tilen MAJERLE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

3rd-part/lwprintf/README.md

@@ -0,0 +1,29 @@
+# Lightweight printf stdio manager
+
+<h3>Read first: <a href="http://docs.majerle.eu/projects/lwprintf/">Documentation</a></h3>
+
+## Features
+
+* Written in C (C11), compatible with ``size_t`` and ``uintmax_t`` types for some specifiers
+* Implements output functions compatible with ``printf``, ``vprintf``, ``snprintf``, ``sprintf`` and ``vsnprintf``
+* Low-memory footprint, suitable for embedded systems
+* Reentrant access to all API functions
+* Operating-system ready
+* Requires single output function to be implemented by user for ``printf``-like API calls
+* With optional functions for operating systems to protect multiple threads printing to the same output stream
+* Allows multiple output stream functions (unlike standard ``printf`` which supports only one) to separate parts of application
+* Added additional specifiers vs original features
+* User friendly MIT license
+
+## Contribute
+
+Fresh contributions are always welcome. Simple instructions to proceed:
+
+1. Fork Github repository
+2. Follow [C style & coding rules](https://github.com/MaJerle/c-code-style) already used in the project
+3. Create a pull request to develop branch with new features or bug fixes
+
+Alternatively you may:
+
+1. Report a bug
+2. Ask for a feature request

3rd-part/lwprintf/lwprintf.h

@@ -0,0 +1,313 @@
+/**
+ * \file            lwprintf.h
+ * \brief           Lightweight stdio manager
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwPRINTF - Lightweight stdio manager library.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.0.5
+ */
+#ifndef LWPRINTF_HDR_H
+#define LWPRINTF_HDR_H
+
+#include <limits.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <string.h>
+#include "lwprintf_opt.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * \defgroup        LWPRINTF Lightweight stdio manager
+ * \brief           Lightweight stdio manager
+ * \{
+ */
+
+/**
+ * \brief           Unused variable macro
+ * \param[in]       x: Unused variable
+ */
+#define LWPRINTF_UNUSED(x)    ((void)(x))
+
+/**
+ * \brief           Calculate size of statically allocated array
+ * \param[in]       x: Input array
+ * \return          Number of array elements
+ */
+#define LWPRINTF_ARRAYSIZE(x) (sizeof(x) / sizeof((x)[0]))
+
+/**
+ * \brief           Forward declaration for LwPRINTF instance
+ */
+struct lwprintf;
+
+/**
+ * \brief           Callback function for character output
+ * \param[in]       ch: Character to print
+ * \param[in]       lwobj: LwPRINTF instance
+ * \return          `ch` on success, `0` to terminate further string processing
+ */
+typedef int (*lwprintf_output_fn)(int ch, struct lwprintf* lwobj);
+
+/**
+ * \brief           LwPRINTF instance
+ */
+typedef struct lwprintf {
+    lwprintf_output_fn out_fn; /*!< Output function for direct print operations */
+#if LWPRINTF_CFG_OS || __DOXYGEN__
+    LWPRINTF_CFG_OS_MUTEX_HANDLE mutex; /*!< OS mutex handle */
+#endif                                  /* LWPRINTF_CFG_OS || __DOXYGEN__ */
+} lwprintf_t;
+
+uint8_t lwprintf_init_ex(lwprintf_t* lwobj, lwprintf_output_fn out_fn);
+int lwprintf_vprintf_ex(lwprintf_t* const lwobj, const char* format, va_list arg);
+int lwprintf_printf_ex(lwprintf_t* const lwobj, const char* format, ...);
+int lwprintf_vsnprintf_ex(lwprintf_t* const lwobj, char* s, size_t n, const char* format, va_list arg);
+int lwprintf_snprintf_ex(lwprintf_t* const lwobj, char* s, size_t n, const char* format, ...);
+uint8_t lwprintf_protect_ex(lwprintf_t* const lwobj);
+uint8_t lwprintf_unprotect_ex(lwprintf_t* const lwobj);
+
+/**
+ * \brief           Write formatted data from variable argument list to sized buffer
+ * \param[in,out]   lwobj: LwPRINTF instance. Set to `NULL` to use default instance
+ * \param[in]       s: Pointer to a buffer where the resulting C-string is stored.
+ *                      The buffer should have a size of at least `n` characters
+ * \param[in]       format: C string that contains a format string that follows the same specifications as format in printf
+ * \param[in]       ...: Optional arguments for format string
+ * \return          The number of characters that would have been written,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_sprintf_ex(lwobj, s, format, ...) lwprintf_snprintf_ex((lwobj), (s), SIZE_MAX, (format), ##__VA_ARGS__)
+
+/**
+ * \brief           Initialize default LwPRINTF instance
+ * \param[in]       out_fn: Output function used for print operation
+ * \return          `1` on success, `0` otherwise
+ * \sa              lwprintf_init_ex
+ */
+#define lwprintf_init(out_fn)                      lwprintf_init_ex(NULL, (out_fn))
+
+/**
+ * \brief           Print formatted data from variable argument list to the output with default LwPRINTF instance
+ * \param[in]       format: C string that contains the text to be written to output
+ * \param[in]       arg: A value identifying a variable arguments list initialized with `va_start`.
+ *                      `va_list` is a special type defined in `<cstdarg>`.
+ * \return          The number of characters that would have been written if `n` had been sufficiently large,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_vprintf(format, arg)              lwprintf_vprintf_ex(NULL, (format), (arg))
+
+/**
+ * \brief           Print formatted data to the output with default LwPRINTF instance
+ * \param[in]       format: C string that contains the text to be written to output
+ * \param[in]       ...: Optional arguments for format string
+ * \return          The number of characters that would have been written if `n` had been sufficiently large,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_printf(format, ...)               lwprintf_printf_ex(NULL, (format), ##__VA_ARGS__)
+
+/**
+ * \brief           Write formatted data from variable argument list to sized buffer with default LwPRINTF instance
+ * \param[in]       s: Pointer to a buffer where the resulting C-string is stored.
+ *                      The buffer should have a size of at least `n` characters
+ * \param[in]       n: Maximum number of bytes to be used in the buffer.
+ *                      The generated string has a length of at most `n - 1`,
+ *                      leaving space for the additional terminating null character
+ * \param[in]       format: C string that contains a format string that follows the same specifications as format in printf
+ * \param[in]       arg: A value identifying a variable arguments list initialized with `va_start`.
+ *                      `va_list` is a special type defined in `<cstdarg>`.
+ * \return          The number of characters that would have been written if `n` had been sufficiently large,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_vsnprintf(s, n, format, arg)      lwprintf_vsnprintf_ex(NULL, (s), (n), (format), (arg))
+
+/**
+ * \brief           Write formatted data from variable argument list to sized buffer with default LwPRINTF instance
+ * \param[in]       s: Pointer to a buffer where the resulting C-string is stored.
+ *                      The buffer should have a size of at least `n` characters
+ * \param[in]       n: Maximum number of bytes to be used in the buffer.
+ *                      The generated string has a length of at most `n - 1`,
+ *                      leaving space for the additional terminating null character
+ * \param[in]       format: C string that contains a format string that follows the same specifications as format in printf
+ * \param[in]       ...: Optional arguments for format string
+ * \return          The number of characters that would have been written if `n` had been sufficiently large,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_snprintf(s, n, format, ...)       lwprintf_snprintf_ex(NULL, (s), (n), (format), ##__VA_ARGS__)
+
+/**
+ * \brief           Write formatted data from variable argument list to sized buffer with default LwPRINTF instance
+ * \param[in]       s: Pointer to a buffer where the resulting C-string is stored.
+ *                      The buffer should have a size of at least `n` characters
+ * \param[in]       format: C string that contains a format string that follows the same specifications as format in printf
+ * \param[in]       ...: Optional arguments for format string
+ * \return          The number of characters that would have been written,
+ *                      not counting the terminating null character.
+ */
+#define lwprintf_sprintf(s, format, ...)           lwprintf_sprintf_ex(NULL, (s), (format), ##__VA_ARGS__)
+
+/**
+ * \brief           Manually enable mutual exclusion
+ * \return          `1` if protected, `0` otherwise
+ */
+#define lwprintf_protect()                         lwprintf_protect_ex(NULL)
+
+/**
+ * \brief           Manually disable mutual exclusion
+ * \return          `1` if protected, `0` otherwise
+ */
+#define lwprintf_unprotect()                       lwprintf_unprotect_ex(NULL)
+
+#if LWPRINTF_CFG_ENABLE_SHORTNAMES || __DOXYGEN__
+
+/**
+ * \copydoc         lwprintf_printf
+ * \note            This function is equivalent to \ref lwprintf_printf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_SHORTNAMES is enabled
+ */
+#define lwprintf    lwprintf_printf
+
+/**
+ * \copydoc         lwprintf_vprintf
+ * \note            This function is equivalent to \ref lwprintf_vprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_SHORTNAMES is enabled
+ */
+#define lwvprintf   lwprintf_vprintf
+
+/**
+ * \copydoc         lwprintf_vsnprintf
+ * \note            This function is equivalent to \ref lwprintf_vsnprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_SHORTNAMES is enabled
+ */
+#define lwvsnprintf lwprintf_vsnprintf
+
+/**
+ * \copydoc         lwprintf_snprintf
+ * \note            This function is equivalent to \ref lwprintf_snprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_SHORTNAMES is enabled
+ */
+#define lwsnprintf  lwprintf_snprintf
+
+/**
+ * \copydoc         lwprintf_sprintf
+ * \note            This function is equivalent to \ref lwprintf_sprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_SHORTNAMES is enabled
+ */
+#define lwsprintf   lwprintf_sprintf
+
+#endif /* LWPRINTF_CFG_ENABLE_SHORTNAMES || __DOXYGEN__ */
+
+#if LWPRINTF_CFG_ENABLE_STD_NAMES || __DOXYGEN__
+
+/**
+ * \copydoc         lwprintf_printf
+ * \note            This function is equivalent to \ref lwprintf_printf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_STD_NAMES is enabled
+ */
+#define printf    lwprintf_printf
+
+/**
+ * \copydoc         lwprintf_vprintf
+ * \note            This function is equivalent to \ref lwprintf_vprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_STD_NAMES is enabled
+ */
+#define vprintf   lwprintf_vprintf
+
+/**
+ * \copydoc         lwprintf_vsnprintf
+ * \note            This function is equivalent to \ref lwprintf_vsnprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_STD_NAMES is enabled
+ */
+#define vsnprintf lwprintf_vsnprintf
+
+/**
+ * \copydoc         lwprintf_snprintf
+ * \note            This function is equivalent to \ref lwprintf_snprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_STD_NAMES is enabled
+ */
+#define snprintf  lwprintf_snprintf
+
+/**
+ * \copydoc         lwprintf_sprintf
+ * \note            This function is equivalent to \ref lwprintf_sprintf
+ *                      and available only if \ref LWPRINTF_CFG_ENABLE_STD_NAMES is enabled
+ */
+#define sprintf   lwprintf_sprintf
+
+#endif /* LWPRINTF_CFG_ENABLE_STD_NAMES || __DOXYGEN__ */
+
+/* Debug module */
+#if !defined(NDEBUG)
+/**
+ * \brief           Debug output function
+ * 
+ *                  Its purpose is to have a debug printout to the defined output,
+ *                  which will get disabled for the release build (when NDEBUG is defined).
+ * 
+ * \note            It calls \ref lwprintf_printf to execute the print
+ * \note            Defined as empty when \ref NDEBUG is enabled
+ * \param[in]       fmt: Format text
+ * \param[in]       ...: Optional formatting parameters
+ */
+#define lwprintf_debug(fmt, ...) lwprintf_printf((fmt), ##__VA_ARGS__)
+/**
+ * \brief           Conditional debug output
+ * 
+ *                  It prints the formatted text only if condition is true
+ * 
+ *                  Its purpose is to have a debug printout to the defined output,
+ *                  which will get disabled for the release build (when NDEBUG is defined).
+ * 
+ * \note            It calls \ref lwprintf_debug to execute the print
+ * \note            Defined as empty when \ref NDEBUG is enabled
+ * \param[in]       cond: Condition to check before outputing the message
+ * \param[in]       fmt: Format text
+ * \param[in]       ...: Optional formatting parameters
+ */
+#define lwprintf_debug_cond(cond, fmt, ...)                                                                            \
+    do {                                                                                                               \
+        if ((cond)) {                                                                                                  \
+            lwprintf_debug((fmt), ##__VA_ARGS__)                                                                       \
+        }                                                                                                              \
+    } while (0)
+#else
+#define lwprintf_debug(fmt, ...)            ((void)0)
+#define lwprintf_debug_cond(cond, fmt, ...) ((void)0)
+#endif
+
+/**
+ * \}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LWPRINTF_HDR_H */

3rd-part/lwprintf/lwprintf_opt.h

@@ -0,0 +1,191 @@
+/**
+ * \file            lwprintf_opt.h
+ * \brief           LwPRINTF options
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwPRINTF - Lightweight stdio manager library.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.0.5
+ */
+#ifndef LWPRINTF_OPT_HDR_H
+#define LWPRINTF_OPT_HDR_H
+
+/* Uncomment to ignore user options (or set macro in compiler flags) */
+/* #define LWPRINTF_IGNORE_USER_OPTS */
+
+/* Include application options */
+#ifndef LWPRINTF_IGNORE_USER_OPTS
+#include "lwprintf_opts.h"
+#endif /* LWPRINTF_IGNORE_USER_OPTS */
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+/**
+ * \defgroup        LWPRINTF_OPT Configuration
+ * \brief           LwPRINTF options
+ * \{
+ */
+
+/**
+ * \brief           Enables `1` or disables `0` operating system support in the library
+ *
+ * \note            When `LWPRINTF_CFG_OS` is enabled, user must implement functions in \ref LWPRINTF_SYS group.
+ */
+#ifndef LWPRINTF_CFG_OS
+#define LWPRINTF_CFG_OS 0
+#endif
+
+/**
+ * \brief           Mutex handle type
+ *
+ * \note            This value must be set in case \ref LWPRINTF_CFG_OS is set to `1`.
+ *                  If data type is not known to compiler, include header file with
+ *                  definition before you define handle type
+ */
+#ifndef LWPRINTF_CFG_OS_MUTEX_HANDLE
+#define LWPRINTF_CFG_OS_MUTEX_HANDLE void*
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` manual mutex lock.
+ *
+ * When this feature is enabled, together with \ref LWPRINTF_CFG_OS, behavior is as following:
+ * - System mutex is kept created during init phase
+ * - Calls to direct printing functions are not thread-safe by default anymore
+ * - Calls to sprintf (buffer functions) are kept thread-safe
+ * - User must manually call \ref lwprintf_protect or \ref lwprintf_protect_ex functions to protect direct printing operation
+ * - User must manually call \ref lwprintf_unprotect or \ref lwprintf_unprotect_ex functions to exit protected area
+ *
+ * \note            If you prefer to completely disable locking mechanism with this library,
+ *                  turn off \ref LWPRINTF_CFG_OS and fully manually handle mutual exclusion for non-reentrant functions
+ */
+#ifndef LWPRINTF_CFG_OS_MANUAL_PROTECT
+#define LWPRINTF_CFG_OS_MANUAL_PROTECT 0
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for `long long int` type, signed or unsigned.
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_LONG_LONG
+#define LWPRINTF_CFG_SUPPORT_LONG_LONG 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for any specifier accepting any kind of integer types.
+ *                  This is enabling `%d, %b, %u, %o, %i, %x` specifiers
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_INT
+#define LWPRINTF_CFG_SUPPORT_TYPE_INT 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support `%p` pointer print type
+ *
+ * When enabled, architecture must support `uintptr_t` type, normally available with C11 standard
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_POINTER
+#define LWPRINTF_CFG_SUPPORT_TYPE_POINTER 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support `%f` float type
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_FLOAT
+#define LWPRINTF_CFG_SUPPORT_TYPE_FLOAT 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for `%e` engineering output type for float numbers
+ *
+ * \note            \ref LWPRINTF_CFG_SUPPORT_TYPE_FLOAT has to be enabled to use this feature
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_ENGINEERING
+#define LWPRINTF_CFG_SUPPORT_TYPE_ENGINEERING 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for `%s` for string output
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_STRING
+#define LWPRINTF_CFG_SUPPORT_TYPE_STRING 1
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` support for `%k` for hex byte array output
+ *
+ */
+#ifndef LWPRINTF_CFG_SUPPORT_TYPE_BYTE_ARRAY
+#define LWPRINTF_CFG_SUPPORT_TYPE_BYTE_ARRAY 1
+#endif
+
+/**
+ * \brief           Specifies default number of precision for floating number
+ *
+ * Represents number of digits to be used after comma if no precision
+ * is set with specifier itself
+ *
+ */
+#ifndef LWPRINTF_CFG_FLOAT_DEFAULT_PRECISION
+#define LWPRINTF_CFG_FLOAT_DEFAULT_PRECISION 6
+#endif
+
+/**
+ * \brief           Enables `1` or disables `0` optional short names for LwPRINTF API functions.
+ *
+ * It adds functions for default instance: `lwprintf`, `lwsnprintf` and others
+ */
+#ifndef LWPRINTF_CFG_ENABLE_SHORTNAMES
+#define LWPRINTF_CFG_ENABLE_SHORTNAMES 1
+#endif /* LWPRINTF_CFG_ENABLE_SHORTNAMES */
+
+/**
+ * \brief           Enables `1` or disables `0` C standard API names
+ *
+ * Disabled by default not to interfere with compiler implementation.
+ * Application may need to remove standard C STDIO library from linkage
+ * to be able to properly compile LwPRINTF with this option enabled
+ */
+#ifndef LWPRINTF_CFG_ENABLE_STD_NAMES
+#define LWPRINTF_CFG_ENABLE_STD_NAMES 0
+#endif /* LWPRINTF_CFG_ENABLE_SHORTNAMES */
+
+/**
+ * \}
+ */
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+#endif /* LWPRINTF_OPT_HDR_H */

3rd-part/lwprintf/lwprintf_opts.h

@@ -0,0 +1,44 @@
+/**
+ * \file            lwprintf_opts_template.h
+ * \brief           LwPRINTF configuration file
+ */
+
+/*
+ * Copyright (c) 2024 Tilen MAJERLE
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without restriction,
+ * including without limitation the rights to use, copy, modify, merge,
+ * publish, distribute, sublicense, and/or sell copies of the Software,
+ * and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE
+ * AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * This file is part of LwPRINTF - Lightweight stdio manager library.
+ *
+ * Author:          Tilen MAJERLE <tilen@majerle.eu>
+ * Version:         v1.0.5
+ */
+#ifndef LWPRINTF_OPTS_HDR_H
+#define LWPRINTF_OPTS_HDR_H
+
+/* Rename this file to "lwprintf_opts.h" for your application */
+
+/*
+ * Open "include/lwprintf/lwprintf_opt.h" and
+ * copy & replace here settings you want to change values
+ */
+
+#endif /* LWPRINTF_OPTS_HDR_H */

BC3S.ATWP

@@ -23,15 +23,6 @@
             <ModeSub name="Debug interface" value="SWD"/>
         </Mode>
     </DEBUG>
-    <I2C1>
-        <Mode>
-            <ModeSub name="I2C" value="I2C"/>
-        </Mode>
-        <Parameters>
-            <ParametersSub name="DualAddressMode" value="DISABLE"/>
-            <ParametersSub name="GeneralCallMode" value="FALSE"/>
-        </Parameters>
-    </I2C1>
     <TMR4>
         <Mode>
             <ModeSub name="Activated" value="TRUE"/>
@@ -46,6 +37,11 @@
             <ModeSub name="Channel1 mode" value="Output_CH1"/>
             <ModeSub name="Activated" value="TRUE"/>
         </Mode>
+        <Parameters>
+            <ParametersSub name="DividerValue" value="143"/>
+            <ParametersSub name="Period" value="999"/>
+            <ParametersSub name="OCMode_1" value="TMR_OUTPUT_CONTROL_PWM_MODE_A"/>
+        </Parameters>
     </TMR10>
     <USART2>
         <Mode>
@@ -62,10 +58,22 @@
         <CAN1_SE_IRQHandler>0;0;0</CAN1_SE_IRQHandler>
         <TMR1_OVF_TMR10_IRQHandler>0;0;0</TMR1_OVF_TMR10_IRQHandler>
         <TMR4_GLOBAL_IRQHandler>1;0;0</TMR4_GLOBAL_IRQHandler>
-        <I2C1_EVT_IRQHandler>0;0;0</I2C1_EVT_IRQHandler>
-        <I2C1_ERR_IRQHandler>0;0;0</I2C1_ERR_IRQHandler>
         <USART2_IRQHandler>0;0;0</USART2_IRQHandler>
     </NVIC>
+    <GPIO>
+        <Signal SignalName="GPIO_Output" PinName="PA4">
+            <Parameters name="GPIO_DriverCapability" value="GPIO_DRIVE_STRENGTH_STRONGER"/>
+        </Signal>
+        <Signal SignalName="GPIO_Output" PinName="PB6">
+            <Parameters name="GPIO_Outputlevel" value="GPIO_OUTPUTLEVEL_HIGH"/>
+            <Parameters name="GPIO_Type" value="GPIO_OUTPUT_OPEN_DRAIN"/>
+            <Parameters name="GPIO_DriverCapability" value="GPIO_DRIVE_STRENGTH_STRONGER"/>
+        </Signal>
+        <Signal SignalName="GPIO_Output" PinName="PB7">
+            <Parameters name="GPIO_Outputlevel" value="GPIO_OUTPUTLEVEL_HIGH"/>
+            <Parameters name="GPIO_Type" value="GPIO_OUTPUT_OPEN_DRAIN"/>
+        </Signal>
+    </GPIO>
     <ClockConfiguration>
         <rtcsel>0</rtcsel>
         <hext>8.000000</hext>
@@ -94,8 +102,8 @@
         <PinSub pinname="PA12" signalname="CAN1_TX" signaltype="2"/>
         <PinSub pinname="PA13" signalname="DEBUG_JTMS_SWDIO" signaltype="2"/>
         <PinSub pinname="PA14" signalname="DEBUG_JTCK_SWCLK" signaltype="2"/>
-        <PinSub pinname="PB6" signalname="I2C1_SCL" signaltype="2"/>
+        <PinSub pinname="PB6" signalname="GPIO_Output" signaltype="3"/>
-        <PinSub pinname="PB7" signalname="I2C1_SDA" signaltype="2"/>
+        <PinSub pinname="PB7" signalname="GPIO_Output" signaltype="3"/>
         <PinSub pinname="PB8" signalname="TMR10_CH1" signaltype="2"/>
     </PINInfo>
     <ProjectInfomation>

app/by_led.c

@@ -0,0 +1,11 @@
+#include "by_led.h"
+
+void by_led_set(uint8_t percent)
+{
+  percent *= 10;
+  if (percent >= 1000) {
+    percent = 1000;
+  }
+
+  tmr_channel_value_set(TMR10, TMR_SELECT_CHANNEL_1, percent);
+}

app/by_led.h

@@ -0,0 +1,8 @@
+#ifndef _BY_LED_H__
+#define _BY_LED_H__
+
+#include "at32f415.h"
+
+extern void by_led_set(uint8_t percent);
+
+#endif

libraries/drivers/src/at32f415_flash.c

@@ -743,7 +743,7 @@ uint16_t flash_slib_end_sector_get(void)
   * @brief  flash crc calibration.
   * @param  start_addr: crc calibration start sector address
   *         sector_cnt: crc calibration sector count
-  * @retval uint32: crc calibration result
+  * @retval uint32_t: crc calibration result
   */
 uint32_t flash_crc_calibrate(uint32_t start_addr, uint32_t sector_cnt)
 {

project/inc/at32f415_conf.h

@@ -62,7 +62,7 @@ extern "C" {
 /*#define EXINT_MODULE_ENABLED--------------------*/
 #define FLASH_MODULE_ENABLED
 #define GPIO_MODULE_ENABLED
-#define I2C_MODULE_ENABLED
+/*#define I2C_MODULE_ENABLED----------------------*/
 #define MISC_MODULE_ENABLED
 #define PWC_MODULE_ENABLED
 /*#define SDIO_MODULE_ENABLED---------------------*/

project/inc/at32f415_wk_config.h

@@ -71,9 +71,6 @@ extern "C" {
   /* init gpio function. */
   void wk_gpio_config(void);
 
-  /* init i2c1 function. */
-  void wk_i2c1_init(void);
-
   /* init can1 function. */
   void wk_can1_init(void);
 

project/inc/by_debug.h

@@ -0,0 +1,35 @@
+#ifndef _BY_DEBUG_H__
+#define _BY_DEBUG_H__
+
+#include <stdio.h>
+#include "at32f415.h"
+#include "lwprintf.h"
+
+#define BY_DEBUG_USART_INDEX (USART2)
+
+#define BY_DEBUG_LOG_MODE    (2) // 0-not log, 1-no debug log, 2-all
+
+#if (BY_DEBUG_LOG_MODE == 2)
+#define LOGI(format, ...) lwprintf("[INFO] " format "\r\n", ##__VA_ARGS__)
+#define LOGW(format, ...) lwprintf("[WARN] " format "\r\n", ##__VA_ARGS__)
+#define LOGE(format, ...) lwprintf("[ERR] " format "\r\n", ##__VA_ARGS__)
+#define LOGD(format, ...) lwprintf("[DEBUG] " format "\r\n", ##__VA_ARGS__)
+#elif (BY_DEBUG_LOG_MODE == 1)
+#define LOGI(format, ...) lwprintf("[INFO] " format "\r\n", ##__VA_ARGS__)
+#define LOGW(format, ...) lwprintf("[WARN] " format "\r\n", ##__VA_ARGS__)
+#define LOGE(format, ...) lwprintf("[ERR] " format "\r\n", ##__VA_ARGS__)
+#define LOGD(format, ...)
+#elif (BY_DEBUG_LOG_MODE == 0)
+#define LOGI(format, ...)
+#define LOGW(format, ...)
+#define LOGE(format, ...)
+#define LOGD(format, ...)
+#endif
+
+extern void by_debug_init(void);
+extern void delay_init(void);
+extern void delay_us(uint32_t nus);
+extern void delay_ms(uint16_t nms);
+extern void delay_sec(uint16_t sec);
+
+#endif

project/src/at32f415_wk_config.c

@@ -165,9 +165,6 @@ void wk_periph_clock_config(void)
   /* enable usart2 periph clock */
   crm_periph_clock_enable(CRM_USART2_PERIPH_CLOCK, TRUE);
 
-  /* enable i2c1 periph clock */
-  crm_periph_clock_enable(CRM_I2C1_PERIPH_CLOCK, TRUE);
-
   /* enable can1 periph clock */
   crm_periph_clock_enable(CRM_CAN1_PERIPH_CLOCK, TRUE);
 }
@@ -214,68 +211,35 @@ void wk_gpio_config(void)
   /* add user code end gpio_config 1 */
 
   /* gpio output config */
-  gpio_bits_reset(GPIOA, GPIO_PINS_8);
+  gpio_bits_reset(GPIOA, GPIO_PINS_4);
+  gpio_bits_set(GPIOB, GPIO_PINS_6 | GPIO_PINS_7);
 
-  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;
+  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_STRONGER;
   gpio_init_struct.gpio_out_type = GPIO_OUTPUT_PUSH_PULL;
   gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
-  gpio_init_struct.gpio_pins = GPIO_PINS_8;
+  gpio_init_struct.gpio_pins = GPIO_PINS_4;
   gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
   gpio_init(GPIOA, &gpio_init_struct);
 
+  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;
+  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
+  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
+  gpio_init_struct.gpio_pins = GPIO_PINS_6;
+  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
+  gpio_init(GPIOB, &gpio_init_struct);
+
+  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;
+  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
+  gpio_init_struct.gpio_mode = GPIO_MODE_OUTPUT;
+  gpio_init_struct.gpio_pins = GPIO_PINS_7;
+  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
+  gpio_init(GPIOB, &gpio_init_struct);
+
   /* add user code begin gpio_config 2 */
 
   /* add user code end gpio_config 2 */
 }
 
-/**
-  * @brief  init i2c1 function.
-  * @param  none
-  * @retval none
-  */
-void wk_i2c1_init(void)
-{
-  /* add user code begin i2c1_init 0 */
-
-  /* add user code end i2c1_init 0 */
-
-  gpio_init_type gpio_init_struct;
-
-  gpio_default_para_init(&gpio_init_struct);
-
-  /* add user code begin i2c1_init 1 */
-
-  /* add user code end i2c1_init 1 */
-
-  /* configure the SCL pin */
-  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
-  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
-  gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
-  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;
-  gpio_init_struct.gpio_pins = GPIO_PINS_6;
-  gpio_init(GPIOB, &gpio_init_struct);
-
-  /* configure the SDA pin */
-  gpio_init_struct.gpio_out_type = GPIO_OUTPUT_OPEN_DRAIN;
-  gpio_init_struct.gpio_pull = GPIO_PULL_NONE;
-  gpio_init_struct.gpio_mode = GPIO_MODE_MUX;
-  gpio_init_struct.gpio_drive_strength = GPIO_DRIVE_STRENGTH_MODERATE;
-  gpio_init_struct.gpio_pins = GPIO_PINS_7;
-  gpio_init(GPIOB, &gpio_init_struct);
-
-  i2c_init(I2C1, I2C_FSMODE_DUTY_2_1, 100000);
-  i2c_own_address1_set(I2C1, I2C_ADDRESS_MODE_7BIT, 0x0);
-  i2c_ack_enable(I2C1, TRUE);
-  i2c_clock_stretch_enable(I2C1, TRUE);
-  i2c_general_call_enable(I2C1, FALSE);
-
-  i2c_enable(I2C1, TRUE);
-
-  /* add user code begin i2c1_init 2 */
-
-  /* add user code end i2c1_init 2 */
-}
-
 /**
   * @brief  init usart2 function
   * @param  none
@@ -394,13 +358,13 @@ void wk_tmr10_init(void)
   gpio_init(GPIOB, &gpio_init_struct);
 
   /* configure counter settings */
-  tmr_base_init(TMR10, 65535, 0);
+  tmr_base_init(TMR10, 999, 143);
   tmr_cnt_dir_set(TMR10, TMR_COUNT_UP);
   tmr_clock_source_div_set(TMR10, TMR_CLOCK_DIV1);
   tmr_period_buffer_enable(TMR10, FALSE);
 
   /* configure channel 1 output settings */
-  tmr_output_struct.oc_mode = TMR_OUTPUT_CONTROL_OFF;
+  tmr_output_struct.oc_mode = TMR_OUTPUT_CONTROL_PWM_MODE_A;
   tmr_output_struct.oc_output_state = TRUE;
   tmr_output_struct.occ_output_state = FALSE;
   tmr_output_struct.oc_polarity = TMR_OUTPUT_ACTIVE_HIGH;
@@ -411,6 +375,8 @@ void wk_tmr10_init(void)
   tmr_channel_value_set(TMR10, TMR_SELECT_CHANNEL_1, 0);
   tmr_output_channel_buffer_enable(TMR10, TMR_SELECT_CHANNEL_1, FALSE);
 
+  tmr_output_channel_immediately_set(TMR10, TMR_SELECT_CHANNEL_1, FALSE);
+
   tmr_counter_enable(TMR10, TRUE);
 
   /* add user code begin tmr10_init 2 */

project/src/by_debug.c

@@ -0,0 +1,98 @@
+#include "by_debug.h"
+
+#include "at32f415.h"
+#include "lwprintf.h"
+
+/* delay macros */
+#define STEP_DELAY_MS 50
+
+/* delay variable */
+static __IO uint32_t fac_us;
+static __IO uint32_t fac_ms;
+
+int lwprintf_out(int ch, lwprintf_t *lwp)
+{
+
+  /* May use printf to output it for test */
+
+  if (ch != '\0') {
+    while (usart_flag_get(BY_DEBUG_USART_INDEX, USART_TDC_FLAG) == RESET);
+    usart_data_transmit(BY_DEBUG_USART_INDEX, (char)ch);
+  }
+
+  return ch;
+}
+
+void by_debug_init(void)
+{
+  lwprintf_init(lwprintf_out);
+}
+
+void delay_init(void)
+{
+  systick_clock_source_config(SYSTICK_CLOCK_SOURCE_AHBCLK_DIV8);
+  crm_clocks_freq_type clocks;
+  crm_clocks_freq_get(&clocks);
+  fac_us = clocks.sclk_freq / (8000000U);
+  fac_ms = fac_us * (1000U);
+}
+
+/**
+ * @brief  inserts a delay time.
+ * @param  nus: specifies the delay time length, in microsecond.
+ * @retval none
+ */
+void delay_us(uint32_t nus)
+{
+  uint32_t temp = 0;
+  SysTick->LOAD = (uint32_t)(nus * fac_us);
+  SysTick->VAL  = 0x00;
+  SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
+  do {
+    temp = SysTick->CTRL;
+  } while ((temp & 0x01) && !(temp & (1 << 16)));
+
+  SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
+  SysTick->VAL = 0x00;
+}
+
+/**
+ * @brief  inserts a delay time.
+ * @param  nms: specifies the delay time length, in milliseconds.
+ * @retval none
+ */
+void delay_ms(uint16_t nms)
+{
+  uint32_t temp = 0;
+  while (nms) {
+    if (nms > STEP_DELAY_MS) {
+      SysTick->LOAD = (uint32_t)(STEP_DELAY_MS * fac_ms);
+      nms -= STEP_DELAY_MS;
+    } else {
+      SysTick->LOAD = (uint32_t)(nms * fac_ms);
+      nms           = 0;
+    }
+    SysTick->VAL = 0x00;
+    SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
+    do {
+      temp = SysTick->CTRL;
+    } while ((temp & 0x01) && !(temp & (1 << 16)));
+
+    SysTick->CTRL &= ~SysTick_CTRL_ENABLE_Msk;
+    SysTick->VAL = 0x00;
+  }
+}
+
+/**
+ * @brief  inserts a delay time.
+ * @param  sec: specifies the delay time, in seconds.
+ * @retval none
+ */
+void delay_sec(uint16_t sec)
+{
+  uint16_t index;
+  for (index = 0; index < sec; index++) {
+    delay_ms(500);
+    delay_ms(500);
+  }
+}

project/src/main.c

@@ -29,7 +29,9 @@
 
 /* private includes ----------------------------------------------------------*/
 /* add user code begin private includes */
-
+#include "vl53l0x_wmd_api.h"
+#include "by_debug.h"
+#include "by_led.h"
 /* add user code end private includes */
 
 /* private typedef -----------------------------------------------------------*/
@@ -70,7 +72,7 @@
 int main(void)
 {
   /* add user code begin 1 */
-
+  by_debug_init();
   /* add user code end 1 */
 
   /* system clock config. */
@@ -88,9 +90,6 @@ int main(void)
   /* init usart2 function. */
   wk_usart2_init();
 
-  /* init i2c1 function. */
-  wk_i2c1_init();
-
   /* init tmr4 function. */
   wk_tmr4_init();
 
@@ -104,13 +103,27 @@ int main(void)
   wk_gpio_config();
 
   /* add user code begin 2 */
+  delay_init();
+  by_led_set(10);
+  delay_ms(1000);
+  VL53L0X_Init();
+  delay_ms(1000);
 
+  by_led_set(0);
   /* add user code end 2 */
 
-  while(1)
+  while (1) {
-  {
     /* add user code begin 3 */
-
+    // gpio_bits_write(GPIOB, GPIO_PINS_8, !gpio_output_data_bit_read(GPIOB, GPIO_PINS_8));
+    // gpio_bits_set(GPIOA, GPIO_PINS_4);
+    // delay_ms(250);
+    // gpio_bits_reset(GPIOA, GPIO_PINS_4);
+    // delay_ms(250);
+    by_led_set(40);
+    delay_ms(10);
+    LOGI("distance:%d", VL53L0X_GetValue());
+    by_led_set(0);
+    delay_ms(10);
     /* add user code end 3 */
   }
 }