boB Rudis
3 years ago
commit
25a2faf308
24 changed files with 3107 additions and 0 deletions
@ -0,0 +1,22 @@ |
|||
^.vscode$ |
|||
^.*\.Rproj$ |
|||
^\.Rproj\.user$ |
|||
^\.travis\.yml$ |
|||
^README\.*Rmd$ |
|||
^README\.*html$ |
|||
^NOTES\.*Rmd$ |
|||
^NOTES\.*html$ |
|||
^\.codecov\.yml$ |
|||
^README_files$ |
|||
^doc$ |
|||
^docs$ |
|||
^tmp$ |
|||
^notes$ |
|||
^CONDUCT.*$ |
|||
^CODE.*$ |
|||
^\.gitlab-ci\.yml$ |
|||
^\.vscode$ |
|||
^CRAN-RELEASE$ |
|||
^appveyor\.yml$ |
|||
^tools$ |
|||
^LICENSE\.md$ |
@ -0,0 +1 @@ |
|||
comment: false |
@ -0,0 +1,9 @@ |
|||
.DS_Store |
|||
.Rproj.user |
|||
.Rhistory |
|||
.RData |
|||
.Rproj |
|||
README_cache |
|||
src/*.o |
|||
src/*.so |
|||
src/*.dll |
@ -0,0 +1,6 @@ |
|||
language: R |
|||
sudo: false |
|||
cache: packages |
|||
|
|||
after_success: |
|||
- Rscript -e 'covr::codecov()' |
@ -0,0 +1,25 @@ |
|||
# Contributor Code of Conduct |
|||
|
|||
As contributors and maintainers of this project, we pledge to respect all people who |
|||
contribute through reporting issues, posting feature requests, updating documentation, |
|||
submitting pull requests or patches, and other activities. |
|||
|
|||
We are committed to making participation in this project a harassment-free experience for |
|||
everyone, regardless of level of experience, gender, gender identity and expression, |
|||
sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion. |
|||
|
|||
Examples of unacceptable behavior by participants include the use of sexual language or |
|||
imagery, derogatory comments or personal attacks, trolling, public or private harassment, |
|||
insults, or other unprofessional conduct. |
|||
|
|||
Project maintainers have the right and responsibility to remove, edit, or reject comments, |
|||
commits, code, wiki edits, issues, and other contributions that are not aligned to this |
|||
Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed |
|||
from the project team. |
|||
|
|||
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by |
|||
opening an issue or contacting one or more of the project maintainers. |
|||
|
|||
This Code of Conduct is adapted from the Contributor Covenant |
|||
(http:contributor-covenant.org), version 1.0.0, available at |
|||
http://contributor-covenant.org/version/1/0/0/ |
@ -0,0 +1,32 @@ |
|||
Package: co2meter |
|||
Type: Package |
|||
Title: Retrieve Readings from CO2Mini (Model RAD-0301) Desktop CO2 Monitor |
|||
Version: 0.1.0 |
|||
Date: 2021-02-21 |
|||
Authors@R: c( |
|||
person("Bob", "Rudis", email = "bob@rud.is", role = c("aut", "cre"), |
|||
comment = c(ORCID = "0000-0001-5670-2640")), |
|||
person("Oleg", "Bulatov", email = "oleg@bulatov.me", role = "aut", |
|||
comment = "co2mon <https://github.com/dmage/co2mon>"), |
|||
person("Oleg", "Bulatov", email = "oleg@bulatov.me", role = "aut", |
|||
comment = "HIDAPI - Multi-Platform library for communication |
|||
with HID devices. <https://github.com/libusb/hidapi>") |
|||
) |
|||
Maintainer: Bob Rudis <bob@rud.is> |
|||
Description: The CO2Mini (model RAD-0301) desktop CO2 monitor from CO2meter.com |
|||
is a low-cost, fairly accurate personal CO2 environment monitor that |
|||
can work standalone (via a USB power brick) or be attacked to a computer |
|||
where it can be both powered and act as a datalogger. Tools are provided |
|||
to retrieve temperature and CO2 readings from such devices. |
|||
URL: https://git.rud.is/hrbrmstr/co2meter |
|||
BugReports: https://git.rud.is/hrbrmstr/co2meter/issues |
|||
RequiresCompilation: yes |
|||
SystemRequirements: macOS, a RAD-0301 sensor |
|||
Encoding: UTF-8 |
|||
License: GPL-3 |
|||
Suggests: |
|||
covr, tinytest |
|||
Depends: |
|||
R (>= 3.6.0) |
|||
Roxygen: list(markdown = TRUE) |
|||
RoxygenNote: 7.1.1 |
@ -0,0 +1,595 @@ |
|||
GNU General Public License |
|||
========================== |
|||
|
|||
_Version 3, 29 June 2007_ |
|||
_Copyright © 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) 2021 Bob Rudis |
|||
|
|||
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: |
|||
|
|||
co2 Copyright (C) 2021 Bob Rudis |
|||
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>>. |
@ -0,0 +1,6 @@ |
|||
# Generated by roxygen2: do not edit by hand |
|||
|
|||
export(close_dev) |
|||
export(init_co2_meter_dev) |
|||
export(read_co2) |
|||
useDynLib(co2meter, .registration = TRUE) |
@ -0,0 +1,2 @@ |
|||
0.1.0 |
|||
* Initial release |
@ -0,0 +1,14 @@ |
|||
#' Retrieve Readings from CO2Mini (Model RAD-0301) Desktop CO2 Monitor |
|||
#' |
|||
#' The CO2Mini (model RAD-0301) desktop CO2 monitor from CO2meter.com |
|||
#' is a low-cost, fairly accurate personal CO2 environment monitor that |
|||
#' can work standalone (via a USB power brick) or be attacked to a computer |
|||
#' where it can be both powered and act as a datalogger. Tools are provided |
|||
#' to retrieve temperature and CO2 readings from such devices. |
|||
#' |
|||
#' @md |
|||
#' @name co2meter |
|||
#' @keywords internal |
|||
#' @author Bob Rudis (bob@@rud.is) |
|||
#' @useDynLib co2meter, .registration = TRUE |
|||
"_PACKAGE" |
@ -0,0 +1,24 @@ |
|||
#' Initialize, read from, and close a co2meter.com device |
|||
#' |
|||
#' @return [get_readings()] returns a named list containing ambient temperature (°C) and CO2 (ppm) |
|||
#' @export |
|||
#' @examples \dontrun{ |
|||
#' init_co2_meter_dev() |
|||
#' read_co2() |
|||
#' close_dev() |
|||
#' } |
|||
read_co2 <- function() { |
|||
.Call("int_get_readings") |
|||
} |
|||
|
|||
#' @rdname read_co2 |
|||
#' @export |
|||
close_dev <- function() { |
|||
tmp <- .Call("int_close_dev") |
|||
} |
|||
|
|||
#' @rdname read_co2 |
|||
#' @export |
|||
init_co2_meter_dev <- function() { |
|||
tmp <- .Call("int_init_dev") |
|||
} |
@ -0,0 +1,63 @@ |
|||
--- |
|||
output: rmarkdown::github_document |
|||
editor_options: |
|||
chunk_output_type: console |
|||
--- |
|||
```{r pkg-knitr-opts, include=FALSE} |
|||
hrbrpkghelpr::global_opts() |
|||
``` |
|||
|
|||
```{r badges, results='asis', echo=FALSE, cache=FALSE} |
|||
hrbrpkghelpr::stinking_badges() |
|||
``` |
|||
|
|||
```{r description, results='asis', echo=FALSE, cache=FALSE} |
|||
hrbrpkghelpr::yank_title_and_description() |
|||
``` |
|||
|
|||
## What's Inside The Tin |
|||
|
|||
The following functions are implemented: |
|||
|
|||
```{r ingredients, results='asis', echo=FALSE, cache=FALSE} |
|||
hrbrpkghelpr::describe_ingredients() |
|||
``` |
|||
|
|||
## Installation |
|||
|
|||
```{r install-ex, results='asis', echo=FALSE, cache=FALSE} |
|||
hrbrpkghelpr::install_block() |
|||
``` |
|||
|
|||
## Usage |
|||
|
|||
```{r lib-ex} |
|||
library(co2meter) |
|||
|
|||
# current version |
|||
packageVersion("co2") |
|||
|
|||
``` |
|||
|
|||
```{r ex-01} |
|||
init_co2_meter_dev() |
|||
|
|||
print(read_co2()) # this can take a few seconds |
|||
|
|||
print(read_co2()) # this can take a few seconds |
|||
|
|||
print(read_co2()) # this can take a few seconds |
|||
|
|||
close_dev() |
|||
``` |
|||
|
|||
## co2 Metrics |
|||
|
|||
```{r cloc, echo=FALSE} |
|||
cloc::cloc_pkg_md() |
|||
``` |
|||
|
|||
## Code of Conduct |
|||
|
|||
Please note that this project is released with a Contributor Code of Conduct. |
|||
By participating in this project you agree to abide by its terms. |
@ -0,0 +1,21 @@ |
|||
Version: 1.0 |
|||
|
|||
RestoreWorkspace: Default |
|||
SaveWorkspace: Default |
|||
AlwaysSaveHistory: Default |
|||
|
|||
EnableCodeIndexing: Yes |
|||
UseSpacesForTab: Yes |
|||
NumSpacesForTab: 2 |
|||
Encoding: UTF-8 |
|||
|
|||
RnwWeave: Sweave |
|||
LaTeX: pdfLaTeX |
|||
|
|||
StripTrailingWhitespace: Yes |
|||
|
|||
BuildType: Package |
|||
PackageUseDevtools: Yes |
|||
PackageInstallArgs: --no-multiarch --with-keep.source |
|||
PackageBuildArgs: --resave-data |
|||
PackageRoxygenize: rd,collate,namespace |
@ -0,0 +1,4 @@ |
|||
|
|||
# Placeholder with simple test |
|||
expect_equal(1 + 1, 2) |
|||
|
@ -0,0 +1,26 @@ |
|||
% Generated by roxygen2: do not edit by hand |
|||
% Please edit documentation in R/co2-package.R |
|||
\docType{package} |
|||
\name{co2meter} |
|||
\alias{co2meter} |
|||
\alias{co2meter-package} |
|||
\title{Retrieve Readings from CO2Mini (Model RAD-0301) Desktop CO2 Monitor} |
|||
\description{ |
|||
The CO2Mini (model RAD-0301) desktop CO2 monitor from CO2meter.com |
|||
is a low-cost, fairly accurate personal CO2 environment monitor that |
|||
can work standalone (via a USB power brick) or be attacked to a computer |
|||
where it can be both powered and act as a datalogger. Tools are provided |
|||
to retrieve temperature and CO2 readings from such devices. |
|||
} |
|||
\seealso{ |
|||
Useful links: |
|||
\itemize{ |
|||
\item \url{https://git.rud.is/hrbrmstr/co2meter} |
|||
\item Report bugs at \url{https://git.rud.is/hrbrmstr/co2meter/issues} |
|||
} |
|||
|
|||
} |
|||
\author{ |
|||
Bob Rudis (bob@rud.is) |
|||
} |
|||
\keyword{internal} |
@ -0,0 +1,27 @@ |
|||
% Generated by roxygen2: do not edit by hand |
|||
% Please edit documentation in R/wrappers.R |
|||
\name{read_co2} |
|||
\alias{read_co2} |
|||
\alias{close_dev} |
|||
\alias{init_co2_meter_dev} |
|||
\title{Initialize, read from, and close a co2meter.com device} |
|||
\usage{ |
|||
read_co2() |
|||
|
|||
close_dev() |
|||
|
|||
init_co2_meter_dev() |
|||
} |
|||
\value{ |
|||
\code{\link[=get_readings]{get_readings()}} returns a named list containing ambient temperature (°C) and CO2 (ppm) |
|||
} |
|||
\description{ |
|||
Initialize, read from, and close a co2meter.com device |
|||
} |
|||
\examples{ |
|||
\dontrun{ |
|||
init_co2_meter_dev() |
|||
read_co2() |
|||
close_dev() |
|||
} |
|||
} |
@ -0,0 +1,7 @@ |
|||
PKG_CPPFLAGS= |
|||
PKG_LIBS= |
|||
|
|||
all: clean |
|||
|
|||
clean: |
|||
rm -Rf $(SHLIB) $(OBJECTS) |
@ -0,0 +1,347 @@ |
|||
/*
|
|||
* co2mon - programming interface to CO2 sensor. |
|||
* Copyright (C) 2015 Oleg Bulatov <oleg@bulatov.me> |
|||
* |
|||
* 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/>.
|
|||
*/ |
|||
|
|||
// https://github.com/dmage/co2mon
|
|||
|
|||
#include <R.h> |
|||
#include <Rinternals.h> |
|||
|
|||
#include <stdio.h> |
|||
#include <stdbool.h> |
|||
#include <stdlib.h> |
|||
#include <string.h> |
|||
|
|||
#include "co2mon.h" |
|||
|
|||
#define CODE_TAMB 0x42 /* Ambient Temperature */ |
|||
#define CODE_CNTR 0x50 /* Relative Concentration of CO2 */ |
|||
|
|||
#define VALUE_MAX 20 |
|||
|
|||
int print_unknown = 0; |
|||
int decode_data = 1; |
|||
|
|||
struct co2mon_state { |
|||
uint16_t data[256]; |
|||
uint8_t seen[32]; |
|||
time_t heatbeat; |
|||
unsigned int deverr; |
|||
}; |
|||
|
|||
int co2mon_init(int decode) { |
|||
int r = hid_init(); |
|||
if (r < 0) fprintf(stderr, "hid_init: error\n"); |
|||
decode_data = decode; |
|||
return r; |
|||
} |
|||
|
|||
void co2mon_exit(void) { if (hid_exit() < 0) fprintf(stderr, "hid_exit: error\n"); } |
|||
|
|||
hid_device *co2mon_open_device(void) { |
|||
hid_device *dev = hid_open(VENDOR_ID, PRODUCT_ID, NULL); |
|||
if (!dev) fprintf(stderr, "hid_open: error\n"); |
|||
return dev; |
|||
} |
|||
|
|||
hid_device *co2mon_open_device_path(const char *path) { |
|||
hid_device *dev = hid_open_path(path); |
|||
if (!dev) fprintf(stderr, "hid_open_path: error\n"); |
|||
return dev; |
|||
} |
|||
|
|||
void co2mon_close_device(hid_device *dev) { hid_close(dev); } |
|||
|
|||
int co2mon_device_path(hid_device *dev, char *str, size_t maxlen) { |
|||
str[0] = '\0'; |
|||
return 1; |
|||
} |
|||
|
|||
int co2mon_send_magic_table(hid_device *dev, co2mon_data_t magic_table) { |
|||
int r = hid_send_feature_report(dev, magic_table, sizeof(co2mon_data_t)); |
|||
if (r < 0 || r != sizeof(co2mon_data_t)) { |
|||
fprintf(stderr, "hid_send_feature_report: error\n"); |
|||
return 0; |
|||
} |
|||
return 1; |
|||
} |
|||
|
|||
static void swap_char(unsigned char *a, unsigned char *b) { |
|||
unsigned char tmp = *a; |
|||
*a = *b; |
|||
*b = tmp; |
|||
} |
|||
|
|||
static void decode_buf(co2mon_data_t result, co2mon_data_t buf, co2mon_data_t magic_table) { |
|||
if (decode_data) { |
|||
swap_char(&buf[0], &buf[2]); |
|||
swap_char(&buf[1], &buf[4]); |
|||
swap_char(&buf[3], &buf[7]); |
|||
swap_char(&buf[5], &buf[6]); |
|||
|
|||
for (int i = 0; i < 8; ++i) buf[i] ^= magic_table[i]; |
|||
|
|||
unsigned char tmp = (buf[7] << 5); |
|||
result[7] = (buf[6] << 5) | (buf[7] >> 3); |
|||
result[6] = (buf[5] << 5) | (buf[6] >> 3); |
|||
result[5] = (buf[4] << 5) | (buf[5] >> 3); |
|||
result[4] = (buf[3] << 5) | (buf[4] >> 3); |
|||
result[3] = (buf[2] << 5) | (buf[3] >> 3); |
|||
result[2] = (buf[1] << 5) | (buf[2] >> 3); |
|||
result[1] = (buf[0] << 5) | (buf[1] >> 3); |
|||
result[0] = tmp | (buf[0] >> 3); |
|||
|
|||
const unsigned char magic_word[8] = "Htemp99e"; |
|||
for (int i = 0; i < 8; ++i) result[i] -= (magic_word[i] << 4) | (magic_word[i] >> 4); |
|||
} else memcpy(result, buf, 8); |
|||
} |
|||
|
|||
int co2mon_read_data(hid_device *dev, co2mon_data_t magic_table, co2mon_data_t result) { |
|||
co2mon_data_t data = { 0 }; |
|||
int actual_length = hid_read_timeout(dev, data, sizeof(co2mon_data_t), 5000 /* milliseconds */); |
|||
if (actual_length < 0) { |
|||
fprintf(stderr, "hid_read_timeout: error\n"); |
|||
return actual_length; |
|||
} |
|||
if (actual_length != sizeof(co2mon_data_t)) { |
|||
fprintf(stderr, "hid_read_timeout: transferred %d bytes, expected %lu bytes\n", actual_length, (unsigned long)sizeof(co2mon_data_t)); |
|||
return 0; |
|||
} |
|||
|
|||
decode_buf(result, data, magic_table); |
|||
return actual_length; |
|||
} |
|||
|
|||
static double decode_temperature(uint16_t w) { return (double)w * 0.0625 - 273.15; } |
|||
|
|||
static int write_value(const char *name, const char *value) { return(1); } |
|||
|
|||
static void write_heartbeat() { |
|||
char buf[VALUE_MAX]; |
|||
const time_t now = time(0); |
|||
snprintf(buf, VALUE_MAX, "%lld", (long long)now); |
|||
write_value("heartbeat", buf); |
|||
} |
|||
|
|||
void dev_loop_init(co2mon_device dev) { |
|||
co2mon_data_t magic_table = { 0 }; |
|||
|
|||
if (!co2mon_send_magic_table(dev, magic_table)) { |
|||
fprintf(stderr, "Unable to send magic table to CO2 device\n"); |
|||
return; |
|||
} |
|||
|
|||
} |
|||
|
|||
reading read_one(co2mon_device dev) { |
|||
co2mon_data_t magic_table = { 0 }; |
|||
co2mon_data_t result; |
|||
reading out = { -99, other }; |
|||
|
|||
int r = co2mon_read_data(dev, magic_table, result); |
|||
if (r <= 0) { |
|||
// fprintf(stderr, "Error while reading data from device\n");
|
|||
out.message = DeviceReadError; |
|||
return(out); |
|||
} |
|||
|
|||
if (result[4] != 0x0d) { |
|||
// fprintf(stderr, "Unexpected data from device (data[4] = %02hhx, want 0x0d)\n", result[4]);
|
|||
out.message = UnexpectedData; |
|||
return(out); |
|||
} |
|||
|
|||
unsigned char r0, r1, r2, r3, checksum; |
|||
r0 = result[0]; |
|||
r1 = result[1]; |
|||
r2 = result[2]; |
|||
r3 = result[3]; |
|||
checksum = r0 + r1 + r2; |
|||
if (checksum != r3) { |
|||
// fprintf(stderr, "checksum error (%02hhx, await %02hhx)\n", checksum, r3);
|
|||
out.message = ChecksumError; |
|||
return(out); |
|||
} |
|||
|
|||
// char buf[VALUE_MAX];
|
|||
uint16_t w = (result[1] << 8) + result[2]; |
|||
|
|||
switch (r0) { |
|||
case CODE_TAMB: |
|||
// snprintf(buf, VALUE_MAX, "%.4f", decode_temperature(w));
|
|||
// printf("Tamb\t%s\n", buf);
|
|||
// fflush(stdout);
|
|||
write_heartbeat(); |
|||
out.sensor = temperature; |
|||
out.value = decode_temperature(w); |
|||
out.message = OK; |
|||
return(out); |
|||
break; |
|||
case CODE_CNTR: |
|||
if ((unsigned)w > 3000) { // Avoid reading spurious (uninitialized?) data
|
|||
break; |
|||
} |
|||
// snprintf(buf, VALUE_MAX, "%d", (int)w);
|
|||
// printf("CntR\t%s\n", buf);
|
|||
// fflush(stdout);
|
|||
write_heartbeat(); |
|||
out.sensor = CO2; |
|||
out.message = OK; |
|||
out.value = (uint16_t)w; |
|||
break; |
|||
default: |
|||
out.message = UnexpectedData; |
|||
if (print_unknown) { |
|||
printf("0x%02hhx\t%d\n", r0, (int)w); |
|||
fflush(stdout); |
|||
} |
|||
} |
|||
|
|||
return(out); |
|||
} |
|||
|
|||
void device_loop(co2mon_device dev) { |
|||
|
|||
co2mon_data_t magic_table = { 0 }; |
|||
co2mon_data_t result; |
|||
|
|||
if (!co2mon_send_magic_table(dev, magic_table)) { |
|||
fprintf(stderr, "Unable to send magic table to CO2 device\n"); |
|||
return; |
|||
} |
|||
|
|||
while (1) { |
|||
|
|||
fprintf(stderr, "Loop\n"); |
|||
int r = co2mon_read_data(dev, magic_table, result); |
|||
if (r <= 0) { |
|||
fprintf(stderr, "Error while reading data from device\n"); |
|||
break; |
|||
} |
|||
|
|||
if (result[4] != 0x0d) { |
|||
fprintf(stderr, "Unexpected data from device (data[4] = %02hhx, want 0x0d)\n", result[4]); |
|||
continue; |
|||
} |
|||
|
|||
unsigned char r0, r1, r2, r3, checksum; |
|||
r0 = result[0]; |
|||
r1 = result[1]; |
|||
r2 = result[2]; |
|||
r3 = result[3]; |
|||
checksum = r0 + r1 + r2; |
|||
if (checksum != r3) { |
|||
fprintf(stderr, "checksum error (%02hhx, await %02hhx)\n", checksum, r3); |
|||
continue; |
|||
} |
|||
|
|||
char buf[VALUE_MAX]; |
|||
uint16_t w = (result[1] << 8) + result[2]; |
|||
|
|||
switch (r0) { |
|||
case CODE_TAMB: |
|||
snprintf(buf, VALUE_MAX, "%.4f", decode_temperature(w)); |
|||
printf("Tamb\t%s\n", buf); |
|||
fflush(stdout); |
|||
write_heartbeat(); |
|||
break; |
|||
case CODE_CNTR: |
|||
if ((unsigned)w > 3000) { // Avoid reading spurious (uninitialized?) data
|
|||
break; |
|||
} |
|||
snprintf(buf, VALUE_MAX, "%d", (int)w); |
|||
printf("CntR\t%s\n", buf); |
|||
fflush(stdout); |
|||
write_heartbeat(); |
|||
break; |
|||
default: |
|||
if (print_unknown) { |
|||
printf("0x%02hhx\t%d\n", r0, (int)w); |
|||
fflush(stdout); |
|||
} |
|||
} |
|||
|
|||
} |
|||
|
|||
} |
|||
|
|||
co2mon_device dev; |
|||
|
|||
SEXP int_init_dev() { |
|||
co2mon_init(0); |
|||
dev = co2mon_open_device(); |
|||
return(R_NilValue); |
|||
} |
|||
|
|||
SEXP int_close_dev() { |
|||
co2mon_close_device(dev); |
|||
co2mon_exit(); |
|||
return(R_NilValue); |
|||
} |
|||
|
|||
SEXP int_get_readings() { |
|||
|
|||
reading rdng, temp, co2; |
|||
|
|||
bool have_temp = false; |
|||
bool have_co2 = false; |
|||
|
|||
for (int i=0; i<=100; i++) { |
|||
|
|||
rdng = read_one(dev); |
|||
|
|||
if (rdng.message == OK) { |
|||
|
|||
if (rdng.sensor == temperature) { |
|||
have_temp = true; |
|||
temp = rdng; |
|||
} else if (rdng.sensor == CO2) { |
|||
have_co2 = true; |
|||
co2 = rdng; |
|||
} |
|||
|
|||
} |
|||
|
|||
if (have_temp && have_co2) { |
|||
break; |
|||
} |
|||
|
|||
} |
|||
|
|||
if (have_temp && have_co2) { |
|||
|
|||
const char *names[] = {"temp", "co2", ""}; |
|||
SEXP out = PROTECT(Rf_mkNamed(VECSXP, names)); |
|||
|
|||
SEXP rtemp = PROTECT(allocVector(REALSXP, 1)); |
|||
SEXP rco2 = PROTECT(allocVector(INTSXP, 1)); |
|||
|
|||
REAL(rtemp)[0] = temp.value; |
|||
INTEGER(rco2)[0] = (int)co2.value; |
|||
|
|||
SET_VECTOR_ELT(out, 0, rtemp); |
|||
SET_VECTOR_ELT(out, 1, rco2); |
|||
|
|||
UNPROTECT(3); |
|||
|
|||
return(out); |
|||
} else { |
|||
return(R_NilValue); |
|||
} |
|||
|
|||
} |
|||
|
@ -0,0 +1,60 @@ |
|||
/*
|
|||
* co2mon - programming interface to CO2 sensor. |
|||
* Copyright (C) 2015 Oleg Bulatov <oleg@bulatov.me> |
|||
* |
|||
* 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/>.
|
|||
*/ |
|||
#ifndef CO2MON_H_INCLUDED_ |
|||
#define CO2MON_H_INCLUDED_ |
|||
|
|||
#include "hidapi.h" |
|||
|
|||
#define VENDOR_ID 0x04d9 |
|||
#define PRODUCT_ID 0xa052 |
|||
|
|||
typedef hid_device *co2mon_device; |
|||
typedef unsigned char co2mon_data_t[8]; |
|||
|
|||
typedef enum { |
|||
temperature = 10, |
|||
CO2 = 20, |
|||
other = 99 |
|||
} sensor_type; |
|||
|
|||
typedef enum { |
|||
DeviceReadError = 10, |
|||
UnexpectedData = 20, |
|||
ChecksumError = 30, |
|||
UnknownData = 40, |
|||
OK = 50 |
|||
} message; |
|||
|
|||
typedef struct { |
|||
double value; |
|||
sensor_type sensor; |
|||
message message; |
|||
} reading; |
|||
|
|||
extern int co2mon_init(int); |
|||
extern void co2mon_exit(void); |
|||
extern co2mon_device co2mon_open_device(void); |
|||
extern co2mon_device co2mon_open_device_path(const char *path); |
|||
extern reading read_one(co2mon_device dev); |
|||
extern void dev_loop_init(co2mon_device dev); |
|||
extern void co2mon_close_device(co2mon_device dev); |
|||
extern int co2mon_device_path(co2mon_device dev, char *str, size_t maxlen); |
|||
extern int co2mon_send_magic_table(co2mon_device dev, co2mon_data_t magic_table); |
|||
extern int co2mon_read_data(co2mon_device dev, co2mon_data_t magic_table, co2mon_data_t result); |
|||
|
|||
#endif |
@ -0,0 +1,23 @@ |
|||
/*
|
|||
* co2mon - programming interface to CO2 sensor. |
|||
* Copyright (C) 2015 Oleg Bulatov <oleg@bulatov.me> |
|||
* |
|||
* 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/>.
|
|||
*/ |
|||
#ifndef CO2_MON_CONFIG_H_INCLUDED_ |
|||
#define CO2_MON_CONFIG_H_INCLUDED_ |
|||
|
|||
/* #undef HAVE_LIBUSB_STRERROR */ |
|||
|
|||
#endif |
File diff suppressed because it is too large
@ -0,0 +1,498 @@ |
|||
/*******************************************************
|
|||
HIDAPI - Multi-Platform library for |
|||
communication with HID devices. |
|||
|
|||
Alan Ott |
|||
Signal 11 Software |
|||
|
|||
8/22/2009 |
|||
|
|||
Copyright 2009, All Rights Reserved. |
|||
|
|||
At the discretion of the user of this library, |
|||
this software may be licensed under the terms of the |
|||
GNU General Public License v3, a BSD-Style license, or the |
|||
original HIDAPI license as outlined in the LICENSE.txt, |
|||
LICENSE-gpl3.txt, LICENSE-bsd.txt, and LICENSE-orig.txt |
|||
files located at the root of the source distribution. |
|||
These files may also be found in the public source |
|||
code repository located at: |
|||
https://github.com/libusb/hidapi .
|
|||
********************************************************/ |
|||
|
|||
/** @file
|
|||
* @defgroup API hidapi API |
|||
*/ |
|||
|
|||
#ifndef HIDAPI_H__ |
|||
#define HIDAPI_H__ |
|||
|
|||
#include <wchar.h> |
|||
|
|||
#ifdef _WIN32 |
|||
#define HID_API_EXPORT __declspec(dllexport) |
|||
#define HID_API_CALL |
|||
#else |
|||
#define HID_API_EXPORT /**< API export macro */ |
|||
#define HID_API_CALL /**< API call macro */ |
|||
#endif |
|||
|
|||
#define HID_API_EXPORT_CALL HID_API_EXPORT HID_API_CALL /**< API export and call macro*/ |
|||
|
|||
/** @brief Static/compile-time major version of the library.
|
|||
|
|||
@ingroup API |
|||
*/ |
|||
#define HID_API_VERSION_MAJOR 0 |
|||
/** @brief Static/compile-time minor version of the library.
|
|||
|
|||
@ingroup API |
|||
*/ |
|||
#define HID_API_VERSION_MINOR 10 |
|||
/** @brief Static/compile-time patch version of the library.
|
|||
|
|||
@ingroup API |
|||
*/ |
|||
#define HID_API_VERSION_PATCH 1 |
|||
|
|||
/* Helper macros */ |
|||
#define HID_API_AS_STR_IMPL(x) #x |
|||
#define HID_API_AS_STR(x) HID_API_AS_STR_IMPL(x) |
|||
#define HID_API_TO_VERSION_STR(v1, v2, v3) HID_API_AS_STR(v1.v2.v3) |
|||
|
|||
/** @brief Static/compile-time string version of the library.
|
|||
|
|||
@ingroup API |
|||
*/ |
|||
#define HID_API_VERSION_STR HID_API_TO_VERSION_STR(HID_API_VERSION_MAJOR, HID_API_VERSION_MINOR, HID_API_VERSION_PATCH) |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
struct hid_api_version { |
|||
int major; |
|||
int minor; |
|||
int patch; |
|||
}; |
|||
|
|||
struct hid_device_; |
|||
typedef struct hid_device_ hid_device; /**< opaque hidapi structure */ |
|||
|
|||
/** hidapi info structure */ |
|||
struct hid_device_info { |
|||
/** Platform-specific device path */ |
|||
char *path; |
|||
/** Device Vendor ID */ |
|||
unsigned short vendor_id; |
|||
/** Device Product ID */ |
|||
unsigned short product_id; |
|||
/** Serial Number */ |
|||
wchar_t *serial_number; |
|||
/** Device Release Number in binary-coded decimal,
|
|||
also known as Device Version Number */ |
|||
unsigned short release_number; |
|||
/** Manufacturer String */ |
|||
wchar_t *manufacturer_string; |
|||
/** Product string */ |
|||
wchar_t *product_string; |
|||
/** Usage Page for this Device/Interface
|
|||
(Windows/Mac/hidraw only) */ |
|||
unsigned short usage_page; |
|||
/** Usage for this Device/Interface
|
|||
(Windows/Mac/hidraw only) */ |
|||
unsigned short usage; |
|||
/** The USB interface which this logical device
|
|||
represents. |
|||
|
|||
* Valid on both Linux implementations in all cases. |
|||
* Valid on the Windows implementation only if the device |
|||
contains more than one interface. |
|||
* Valid on the Mac implementation if and only if the device |
|||
is a USB HID device. */ |
|||
int interface_number; |
|||
|
|||
/** Pointer to the next device */ |
|||
struct hid_device_info *next; |
|||
}; |
|||
|
|||
|
|||
/** @brief Initialize the HIDAPI library.
|
|||
|
|||
This function initializes the HIDAPI library. Calling it is not |
|||
strictly necessary, as it will be called automatically by |
|||
hid_enumerate() and any of the hid_open_*() functions if it is |
|||
needed. This function should be called at the beginning of |
|||
execution however, if there is a chance of HIDAPI handles |
|||
being opened by different threads simultaneously. |
|||
|
|||
@ingroup API |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_init(void); |
|||
|
|||
/** @brief Finalize the HIDAPI library.
|
|||
|
|||
This function frees all of the static data associated with |
|||
HIDAPI. It should be called at the end of execution to avoid |
|||
memory leaks. |
|||
|
|||
@ingroup API |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_exit(void); |
|||
|
|||
/** @brief Enumerate the HID Devices.
|
|||
|
|||
This function returns a linked list of all the HID devices |
|||
attached to the system which match vendor_id and product_id. |
|||
If @p vendor_id is set to 0 then any vendor matches. |
|||
If @p product_id is set to 0 then any product matches. |
|||
If @p vendor_id and @p product_id are both set to 0, then |
|||
all HID devices will be returned. |
|||
|
|||
@ingroup API |
|||
@param vendor_id The Vendor ID (VID) of the types of device |
|||
to open. |
|||
@param product_id The Product ID (PID) of the types of |
|||
device to open. |
|||
|
|||
@returns |
|||
This function returns a pointer to a linked list of type |
|||
struct #hid_device_info, containing information about the HID devices |
|||
attached to the system, or NULL in the case of failure. Free |
|||
this linked list by calling hid_free_enumeration(). |
|||
*/ |
|||
struct hid_device_info HID_API_EXPORT * HID_API_CALL hid_enumerate(unsigned short vendor_id, unsigned short product_id); |
|||
|
|||
/** @brief Free an enumeration Linked List
|
|||
|
|||
This function frees a linked list created by hid_enumerate(). |
|||
|
|||
@ingroup API |
|||
@param devs Pointer to a list of struct_device returned from |
|||
hid_enumerate(). |
|||
*/ |
|||
void HID_API_EXPORT HID_API_CALL hid_free_enumeration(struct hid_device_info *devs); |
|||
|
|||
/** @brief Open a HID device using a Vendor ID (VID), Product ID
|
|||
(PID) and optionally a serial number. |
|||
|
|||
If @p serial_number is NULL, the first device with the |
|||
specified VID and PID is opened. |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param vendor_id The Vendor ID (VID) of the device to open. |
|||
@param product_id The Product ID (PID) of the device to open. |
|||
@param serial_number The Serial Number of the device to open |
|||
(Optionally NULL). |
|||
|
|||
@returns |
|||
This function returns a pointer to a #hid_device object on |
|||
success or NULL on failure. |
|||
*/ |
|||
HID_API_EXPORT hid_device * HID_API_CALL hid_open(unsigned short vendor_id, unsigned short product_id, const wchar_t *serial_number); |
|||
|
|||
/** @brief Open a HID device by its path name.
|
|||
|
|||
The path name be determined by calling hid_enumerate(), or a |
|||
platform-specific path name can be used (eg: /dev/hidraw0 on |
|||
Linux). |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param path The path name of the device to open |
|||
|
|||
@returns |
|||
This function returns a pointer to a #hid_device object on |
|||
success or NULL on failure. |
|||
*/ |
|||
HID_API_EXPORT hid_device * HID_API_CALL hid_open_path(const char *path); |
|||
|
|||
/** @brief Write an Output report to a HID device.
|
|||
|
|||
The first byte of @p data[] must contain the Report ID. For |
|||
devices which only support a single report, this must be set |
|||
to 0x0. The remaining bytes contain the report data. Since |
|||
the Report ID is mandatory, calls to hid_write() will always |
|||
contain one more byte than the report contains. For example, |
|||
if a hid report is 16 bytes long, 17 bytes must be passed to |
|||
hid_write(), the Report ID (or 0x0, for devices with a |
|||
single report), followed by the report data (16 bytes). In |
|||
this example, the length passed in would be 17. |
|||
|
|||
hid_write() will send the data on the first OUT endpoint, if |
|||
one exists. If it does not, it will send the data through |
|||
the Control Endpoint (Endpoint 0). |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data The data to send, including the report number as |
|||
the first byte. |
|||
@param length The length in bytes of the data to send. |
|||
|
|||
@returns |
|||
This function returns the actual number of bytes written and |
|||
-1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_write(hid_device *dev, const unsigned char *data, size_t length); |
|||
|
|||
/** @brief Read an Input report from a HID device with timeout.
|
|||
|
|||
Input reports are returned |
|||
to the host through the INTERRUPT IN endpoint. The first byte will |
|||
contain the Report number if the device uses numbered reports. |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data A buffer to put the read data into. |
|||
@param length The number of bytes to read. For devices with |
|||
multiple reports, make sure to read an extra byte for |
|||
the report number. |
|||
@param milliseconds timeout in milliseconds or -1 for blocking wait. |
|||
|
|||
@returns |
|||
This function returns the actual number of bytes read and |
|||
-1 on error. If no packet was available to be read within |
|||
the timeout period, this function returns 0. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_read_timeout(hid_device *dev, unsigned char *data, size_t length, int milliseconds); |
|||
|
|||
/** @brief Read an Input report from a HID device.
|
|||
|
|||
Input reports are returned |
|||
to the host through the INTERRUPT IN endpoint. The first byte will |
|||
contain the Report number if the device uses numbered reports. |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data A buffer to put the read data into. |
|||
@param length The number of bytes to read. For devices with |
|||
multiple reports, make sure to read an extra byte for |
|||
the report number. |
|||
|
|||
@returns |
|||
This function returns the actual number of bytes read and |
|||
-1 on error. If no packet was available to be read and |
|||
the handle is in non-blocking mode, this function returns 0. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_read(hid_device *dev, unsigned char *data, size_t length); |
|||
|
|||
/** @brief Set the device handle to be non-blocking.
|
|||
|
|||
In non-blocking mode calls to hid_read() will return |
|||
immediately with a value of 0 if there is no data to be |
|||
read. In blocking mode, hid_read() will wait (block) until |
|||
there is data to read before returning. |
|||
|
|||
Nonblocking can be turned on and off at any time. |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param nonblock enable or not the nonblocking reads |
|||
- 1 to enable nonblocking |
|||
- 0 to disable nonblocking. |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_set_nonblocking(hid_device *dev, int nonblock); |
|||
|
|||
/** @brief Send a Feature report to the device.
|
|||
|
|||
Feature reports are sent over the Control endpoint as a |
|||
Set_Report transfer. The first byte of @p data[] must |
|||
contain the Report ID. For devices which only support a |
|||
single report, this must be set to 0x0. The remaining bytes |
|||
contain the report data. Since the Report ID is mandatory, |
|||
calls to hid_send_feature_report() will always contain one |
|||
more byte than the report contains. For example, if a hid |
|||
report is 16 bytes long, 17 bytes must be passed to |
|||
hid_send_feature_report(): the Report ID (or 0x0, for |
|||
devices which do not use numbered reports), followed by the |
|||
report data (16 bytes). In this example, the length passed |
|||
in would be 17. |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data The data to send, including the report number as |
|||
the first byte. |
|||
@param length The length in bytes of the data to send, including |
|||
the report number. |
|||
|
|||
@returns |
|||
This function returns the actual number of bytes written and |
|||
-1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_send_feature_report(hid_device *dev, const unsigned char *data, size_t length); |
|||
|
|||
/** @brief Get a feature report from a HID device.
|
|||
|
|||
Set the first byte of @p data[] to the Report ID of the |
|||
report to be read. Make sure to allow space for this |
|||
extra byte in @p data[]. Upon return, the first byte will |
|||
still contain the Report ID, and the report data will |
|||
start in data[1]. |
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data A buffer to put the read data into, including |
|||
the Report ID. Set the first byte of @p data[] to the |
|||
Report ID of the report to be read, or set it to zero |
|||
if your device does not use numbered reports. |
|||
@param length The number of bytes to read, including an |
|||
extra byte for the report ID. The buffer can be longer |
|||
than the actual report. |
|||
|
|||
@returns |
|||
This function returns the number of bytes read plus |
|||
one for the report ID (which is still in the first |
|||
byte), or -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_get_feature_report(hid_device *dev, unsigned char *data, size_t length); |
|||
|
|||
/** @brief Get a input report from a HID device.
|
|||
|
|||
Set the first byte of @p data[] to the Report ID of the |
|||
report to be read. Make sure to allow space for this |
|||
extra byte in @p data[]. Upon return, the first byte will |
|||
still contain the Report ID, and the report data will |
|||
start in data[1]. |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param data A buffer to put the read data into, including |
|||
the Report ID. Set the first byte of @p data[] to the |
|||
Report ID of the report to be read, or set it to zero |
|||
if your device does not use numbered reports. |
|||
@param length The number of bytes to read, including an |
|||
extra byte for the report ID. The buffer can be longer |
|||
than the actual report. |
|||
|
|||
@returns |
|||
This function returns the number of bytes read plus |
|||
one for the report ID (which is still in the first |
|||
byte), or -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT HID_API_CALL hid_get_input_report(hid_device *dev, unsigned char *data, size_t length); |
|||
|
|||
/** @brief Close a HID device.
|
|||
|
|||
This function sets the return value of hid_error(). |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
*/ |
|||
void HID_API_EXPORT HID_API_CALL hid_close(hid_device *dev); |
|||
|
|||
/** @brief Get The Manufacturer String from a HID device.
|
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param string A wide string buffer to put the data into. |
|||
@param maxlen The length of the buffer in multiples of wchar_t. |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT_CALL hid_get_manufacturer_string(hid_device *dev, wchar_t *string, size_t maxlen); |
|||
|
|||
/** @brief Get The Product String from a HID device.
|
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param string A wide string buffer to put the data into. |
|||
@param maxlen The length of the buffer in multiples of wchar_t. |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT_CALL hid_get_product_string(hid_device *dev, wchar_t *string, size_t maxlen); |
|||
|
|||
/** @brief Get The Serial Number String from a HID device.
|
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param string A wide string buffer to put the data into. |
|||
@param maxlen The length of the buffer in multiples of wchar_t. |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT_CALL hid_get_serial_number_string(hid_device *dev, wchar_t *string, size_t maxlen); |
|||
|
|||
/** @brief Get a string from a HID device, based on its string index.
|
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(). |
|||
@param string_index The index of the string to get. |
|||
@param string A wide string buffer to put the data into. |
|||
@param maxlen The length of the buffer in multiples of wchar_t. |
|||
|
|||
@returns |
|||
This function returns 0 on success and -1 on error. |
|||
*/ |
|||
int HID_API_EXPORT_CALL hid_get_indexed_string(hid_device *dev, int string_index, wchar_t *string, size_t maxlen); |
|||
|
|||
/** @brief Get a string describing the last error which occurred.
|
|||
|
|||
Whether a function sets the last error is noted in its |
|||
documentation. These functions will reset the last error |
|||
to NULL before their execution. |
|||
|
|||
Strings returned from hid_error() must not be freed by the user! |
|||
|
|||
This function is thread-safe, and error messages are thread-local. |
|||
|
|||
@ingroup API |
|||
@param dev A device handle returned from hid_open(), |
|||
or NULL to get the last non-device-specific error |
|||
(e.g. for errors in hid_open() itself). |
|||
|
|||
@returns |
|||
This function returns a string containing the last error |
|||
which occurred or NULL if none has occurred. |
|||
*/ |
|||
HID_API_EXPORT const wchar_t* HID_API_CALL hid_error(hid_device *dev); |
|||
|
|||
/** @brief Get a runtime version of the library.
|
|||
|
|||
@ingroup API |
|||
|
|||
@returns |
|||
Pointer to statically allocated struct, that contains version. |
|||
*/ |
|||
HID_API_EXPORT const struct hid_api_version* HID_API_CALL hid_version(void); |
|||
|
|||
|
|||
/** @brief Get a runtime version string of the library.
|
|||
|
|||
@ingroup API |
|||
|
|||
@returns |
|||
Pointer to statically allocated string, that contains version string. |
|||
*/ |
|||
HID_API_EXPORT const char* HID_API_CALL hid_version_str(void); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
|
@ -0,0 +1,20 @@ |
|||
#include <R.h> |
|||
#include <Rinternals.h> |
|||
#include <stdlib.h> // for NULL |
|||
#include <R_ext/Rdynload.h> |
|||
|
|||
extern SEXP int_close_dev(); |
|||
extern SEXP int_get_readings(); |
|||
extern SEXP int_init_dev(); |
|||
|
|||
static const R_CallMethodDef CallEntries[] = { |
|||
{"int_close_dev", (DL_FUNC) &int_close_dev, 0}, |
|||
{"int_get_readings", (DL_FUNC) &int_get_readings, 0}, |
|||
{"int_init_dev", (DL_FUNC) &int_init_dev, 0}, |
|||
{NULL, NULL, 0} |
|||
}; |
|||
|
|||
void R_init_co2(DllInfo *dll) { |
|||
R_registerRoutines(dll, NULL, CallEntries, NULL, NULL); |
|||
R_useDynamicSymbols(dll, FALSE); |
|||
} |
@ -0,0 +1,5 @@ |
|||
|
|||
if ( requireNamespace("tinytest", quietly=TRUE) ){ |
|||
tinytest::test_package("co2meter") |
|||
} |
|||
|
Loading…
Reference in new issue