mirror of https://github.com/arendst/Tasmota.git
Merge branch 'development' into boards_refac
This commit is contained in:
Jason2866
GitHub
commit
c445a88176
|
|
@ -5,12 +5,15 @@ All notable changes to this project will be documented in this file.
|
|||
|
||||
## [12.2.0.1]
|
||||
### Added
|
||||
- DS18x20 support on up to four GPIOs by md5sum-as (#16833)
|
||||
|
||||
### Breaking Changed
|
||||
|
||||
### Changed
|
||||
- DS18x20 ``DS18Alias`` to ``DS18Sens`` (#16833)
|
||||
|
||||
### Fixed
|
||||
- BP5758D red channel corruption regression from v12.1.1.6 (#16850)
|
||||
|
||||
### Removed
|
||||
|
||||
|
|
|
|||
|
|
@ -109,11 +109,14 @@ The latter links can be used for OTA upgrades too like ``OtaUrl http://ota.tasmo
|
|||
|
||||
## Changelog v12.2.0.1
|
||||
### Added
|
||||
- DS18x20 support on up to four GPIOs by md5sum-as [#16833](https://github.com/arendst/Tasmota/issues/16833)
|
||||
|
||||
### Breaking Changed
|
||||
|
||||
### Changed
|
||||
- DS18x20 ``DS18Alias`` to ``DS18Sens`` [#16833](https://github.com/arendst/Tasmota/issues/16833)
|
||||
|
||||
### Fixed
|
||||
- BP5758D red channel corruption regression from v12.1.1.6 [#16850](https://github.com/arendst/Tasmota/issues/16850)
|
||||
|
||||
### Removed
|
||||
|
|
|
|||
|
|
@ -1,202 +0,0 @@
|
|||
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
|
@ -1,368 +0,0 @@
|
|||
# ESP32 Camera Driver
|
||||
|
||||
[](https://github.com/espressif/esp32-camera/actions/workflows/build.yml)
|
||||
## General Information
|
||||
|
||||
This repository hosts ESP32 series Soc compatible driver for image sensors. Additionally it provides a few tools, which allow converting the captured frame data to the more common BMP and JPEG formats.
|
||||
|
||||
### Supported Soc
|
||||
|
||||
- ESP32
|
||||
- ESP32-S2
|
||||
- ESP32-S3
|
||||
|
||||
### Supported Sensor
|
||||
|
||||
| model | max resolution | color type | output format | Len Size |
|
||||
| ------- | -------------- | ---------- | ------------------------------------------------------------ | -------- |
|
||||
| OV2640 | 1600 x 1200 | color | YUV(422/420)/YCbCr422<br>RGB565/555<br>8-bit compressed data<br>8/10-bit Raw RGB data | 1/4" |
|
||||
| OV3660 | 2048 x 1536 | color | raw RGB data<br/>RGB565/555/444<br/>CCIR656<br/>YCbCr422<br/>compression | 1/5" |
|
||||
| OV5640 | 2592 x 1944 | color | RAW RGB<br/>RGB565/555/444<br/>CCIR656<br/>YUV422/420<br/>YCbCr422<br/>compression | 1/4" |
|
||||
| OV7670 | 640 x 480 | color | Raw Bayer RGB<br/>Processed Bayer RGB<br>YUV/YCbCr422<br>GRB422<br>RGB565/555 | 1/6" |
|
||||
| OV7725 | 640 x 480 | color | Raw RGB<br/>GRB 422<br/>RGB565/555/444<br/>YCbCr 422 | 1/4" |
|
||||
| NT99141 | 1280 x 720 | color | YCbCr 422<br/>RGB565/555/444<br/>Raw<br/>CCIR656<br/>JPEG compression | 1/4" |
|
||||
| GC032A | 640 x 480 | color | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565 | 1/10" |
|
||||
| GC0308 | 640 x 480 | color | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565 | 1/6.5" |
|
||||
| GC2145 | 1600 x 1200 | color | YUV/YCbCr422<br/>RAW Bayer<br/>RGB565 | 1/5" |
|
||||
|
||||
## Important to Remember
|
||||
|
||||
- Except when using CIF or lower resolution with JPEG, the driver requires PSRAM to be installed and activated.
|
||||
- Using YUV or RGB puts a lot of strain on the chip because writing to PSRAM is not particularly fast. The result is that image data might be missing. This is particularly true if WiFi is enabled. If you need RGB data, it is recommended that JPEG is captured and then turned into RGB using `fmt2rgb888` or `fmt2bmp`/`frame2bmp`.
|
||||
- When 1 frame buffer is used, the driver will wait for the current frame to finish (VSYNC) and start I2S DMA. After the frame is acquired, I2S will be stopped and the frame buffer returned to the application. This approach gives more control over the system, but results in longer time to get the frame.
|
||||
- When 2 or more frame bufers are used, I2S is running in continuous mode and each frame is pushed to a queue that the application can access. This approach puts more strain on the CPU/Memory, but allows for double the frame rate. Please use only with JPEG.
|
||||
|
||||
## Installation Instructions
|
||||
|
||||
|
||||
### Using esp-idf
|
||||
|
||||
- Clone or download and extract the repository to the components folder of your ESP-IDF project
|
||||
- Enable PSRAM in `menuconfig` (also set Flash and PSRAM frequiencies to 80MHz)
|
||||
- Include `esp_camera.h` in your code
|
||||
|
||||
### Using PlatformIO
|
||||
|
||||
The easy way -- on the `env` section of `platformio.ini`, add the following:
|
||||
|
||||
```ini
|
||||
[env]
|
||||
lib_deps =
|
||||
esp32-camera
|
||||
```
|
||||
|
||||
Now the `esp_camera.h` is available to be included:
|
||||
|
||||
```c
|
||||
#include "esp_camera.h"
|
||||
```
|
||||
|
||||
Enable PSRAM on `menuconfig` or type it direclty on `sdkconfig`. Check the [official doc](https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/kconfig.html#config-esp32-spiram-support) for more info.
|
||||
|
||||
```
|
||||
CONFIG_ESP32_SPIRAM_SUPPORT=y
|
||||
```
|
||||
|
||||
***Arduino*** The easy-way (content above) only seems to work if you're using `framework=arduino` which seems to take a bunch of the guesswork out (thanks Arduino!) but also suck up a lot more memory and flash, almost crippling the performance. If you plan to use the `framework=espidf` then read the sections below carefully!!
|
||||
|
||||
## Platform.io lib/submodule (for framework=espidf)
|
||||
|
||||
It's probably easier to just skip the platform.io library registry version and link the git repo as a submodule. (i.e. using code outside the platform.io library management). In this example we will install this as a submodule inside the platform.io $project/lib folder:
|
||||
```
|
||||
cd $project\lib
|
||||
git submodule add -b master https://github.com/espressif/esp32-camera.git
|
||||
```
|
||||
|
||||
Then in `platformio.ini` file
|
||||
```
|
||||
build_flags =
|
||||
-I../lib/esp32-camera
|
||||
```
|
||||
After that `#include "esp_camera.h"` statement will be available. Now the module is included, and you're hopefully back to the same place as the easy-Arduino way.
|
||||
|
||||
**Warning about platform.io/espidf and fresh (not initialized) git repos**
|
||||
There is a sharp-edge on you'll discover in the platform.io build process (in espidf v3.3 & 4.0.1) where a project which has only had `git init` but nothing committed will crash platform.io build process with highly non-useful output. The cause is due to lack of a version (making you think you did something wrong, when you didn't at all) - the output is horribly non-descript. Solution: the devs want you to create a file called version.txt with a number in it, or simply commit any file to the projects git repo and use git. This happens because platform.io build process tries to be too clever and determine the build version number from the git repo - it's a sharp edge you'll only encounter if you're experimenting on a new project with no commits .. like wtf is my camera not working let's try a 'clean project'?! </rant>
|
||||
|
||||
## Platform.io Kconfig
|
||||
Kconfig is used by the platform.io menuconfig (accessed by running: `pio run -t menuconfig`) to interactively manage the various #ifdef statements throughout the espidf and supporting libraries (i.e. this repo: esp32-camera and arduino-esp32.git). The menuconfig process generates the `sdkconfig` file which is ultimately used behind the scenes by espidf compile+build process.
|
||||
|
||||
**Make sure to append or symlink** [this `Kconfig`](./Kconfig) content into the `Kconfig` of your project.
|
||||
|
||||
You symlink (or copy) the included Kconfig into your platform.io projects src directory. The file should be named `Kconfig.projbuild` in your projects src\ directory or you could also add the library path to a CMakefile.txt and hope the `Kconfig` (or `Kconfig.projbuild`) gets discovered by the menuconfig process, though this unpredictable for me.
|
||||
|
||||
The unpredictable wonky behavior in platform.io build process around Kconfig naming (Kconfig vs. Kconfig.projbuild) occurs between espidf versions 3.3 and 4.0 - but if you don't see "Camera configuration" in your `pio run -t menuconfig` then there is no point trying to test camera code (it may compile, but it probably won't work!) and it seems the platform.io devs (when they built their wrapper around the espidf menuconfig) didn't implement it properly. You've probably already figured out you can't use the espidf build tools since the files are in totally different locations and also different versions with sometimes different syntax. This is one of those times you might consider changing the `platformio.ini` from `platform=espressif32` to `platform=https://github.com/platformio/platform-espressif32.git#develop` to get a more recent version of the espidf 4.0 tools.
|
||||
|
||||
However with a bit of patience and experimenting you'll figure the Kconfig out. Once Kconfig (or Kconfig.projbuild) is working then you will be able to choose the configurations according to your setup or the camera libraries will be compiled. Although you might also need to delete your .pio/build directory before the options appear .. again, the `pio run -t menuconfig` doens't always notice the new Kconfig files!
|
||||
|
||||
If you miss-skip-ignore this critical step the camera module will compile but camera logic inside the library will be 'empty' because the Kconfig sets the proper #ifdef statements during the build process to initialize the selected cameras. It's very not optional!
|
||||
|
||||
|
||||
## Examples
|
||||
|
||||
### Initialization
|
||||
|
||||
```c
|
||||
#include "esp_camera.h"
|
||||
|
||||
//WROVER-KIT PIN Map
|
||||
#define CAM_PIN_PWDN -1 //power down is not used
|
||||
#define CAM_PIN_RESET -1 //software reset will be performed
|
||||
#define CAM_PIN_XCLK 21
|
||||
#define CAM_PIN_SIOD 26
|
||||
#define CAM_PIN_SIOC 27
|
||||
|
||||
#define CAM_PIN_D7 35
|
||||
#define CAM_PIN_D6 34
|
||||
#define CAM_PIN_D5 39
|
||||
#define CAM_PIN_D4 36
|
||||
#define CAM_PIN_D3 19
|
||||
#define CAM_PIN_D2 18
|
||||
#define CAM_PIN_D1 5
|
||||
#define CAM_PIN_D0 4
|
||||
#define CAM_PIN_VSYNC 25
|
||||
#define CAM_PIN_HREF 23
|
||||
#define CAM_PIN_PCLK 22
|
||||
|
||||
static camera_config_t camera_config = {
|
||||
.pin_pwdn = CAM_PIN_PWDN,
|
||||
.pin_reset = CAM_PIN_RESET,
|
||||
.pin_xclk = CAM_PIN_XCLK,
|
||||
.pin_sscb_sda = CAM_PIN_SIOD,
|
||||
.pin_sscb_scl = CAM_PIN_SIOC,
|
||||
|
||||
.pin_d7 = CAM_PIN_D7,
|
||||
.pin_d6 = CAM_PIN_D6,
|
||||
.pin_d5 = CAM_PIN_D5,
|
||||
.pin_d4 = CAM_PIN_D4,
|
||||
.pin_d3 = CAM_PIN_D3,
|
||||
.pin_d2 = CAM_PIN_D2,
|
||||
.pin_d1 = CAM_PIN_D1,
|
||||
.pin_d0 = CAM_PIN_D0,
|
||||
.pin_vsync = CAM_PIN_VSYNC,
|
||||
.pin_href = CAM_PIN_HREF,
|
||||
.pin_pclk = CAM_PIN_PCLK,
|
||||
|
||||
.xclk_freq_hz = 20000000,//EXPERIMENTAL: Set to 16MHz on ESP32-S2 or ESP32-S3 to enable EDMA mode
|
||||
.ledc_timer = LEDC_TIMER_0,
|
||||
.ledc_channel = LEDC_CHANNEL_0,
|
||||
|
||||
.pixel_format = PIXFORMAT_JPEG,//YUV422,GRAYSCALE,RGB565,JPEG
|
||||
.frame_size = FRAMESIZE_UXGA,//QQVGA-QXGA Do not use sizes above QVGA when not JPEG
|
||||
|
||||
.jpeg_quality = 12, //0-63 lower number means higher quality
|
||||
.fb_count = 1, //if more than one, i2s runs in continuous mode. Use only with JPEG
|
||||
.grab_mode = CAMERA_GRAB_WHEN_EMPTY//CAMERA_GRAB_LATEST. Sets when buffers should be filled
|
||||
};
|
||||
|
||||
esp_err_t camera_init(){
|
||||
//power up the camera if PWDN pin is defined
|
||||
if(CAM_PIN_PWDN != -1){
|
||||
pinMode(CAM_PIN_PWDN, OUTPUT);
|
||||
digitalWrite(CAM_PIN_PWDN, LOW);
|
||||
}
|
||||
|
||||
//initialize the camera
|
||||
esp_err_t err = esp_camera_init(&camera_config);
|
||||
if (err != ESP_OK) {
|
||||
ESP_LOGE(TAG, "Camera Init Failed");
|
||||
return err;
|
||||
}
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
|
||||
esp_err_t camera_capture(){
|
||||
//acquire a frame
|
||||
camera_fb_t * fb = esp_camera_fb_get();
|
||||
if (!fb) {
|
||||
ESP_LOGE(TAG, "Camera Capture Failed");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
//replace this with your own function
|
||||
process_image(fb->width, fb->height, fb->format, fb->buf, fb->len);
|
||||
|
||||
//return the frame buffer back to the driver for reuse
|
||||
esp_camera_fb_return(fb);
|
||||
return ESP_OK;
|
||||
}
|
||||
```
|
||||
|
||||
### JPEG HTTP Capture
|
||||
|
||||
```c
|
||||
#include "esp_camera.h"
|
||||
#include "esp_http_server.h"
|
||||
#include "esp_timer.h"
|
||||
|
||||
typedef struct {
|
||||
httpd_req_t *req;
|
||||
size_t len;
|
||||
} jpg_chunking_t;
|
||||
|
||||
static size_t jpg_encode_stream(void * arg, size_t index, const void* data, size_t len){
|
||||
jpg_chunking_t *j = (jpg_chunking_t *)arg;
|
||||
if(!index){
|
||||
j->len = 0;
|
||||
}
|
||||
if(httpd_resp_send_chunk(j->req, (const char *)data, len) != ESP_OK){
|
||||
return 0;
|
||||
}
|
||||
j->len += len;
|
||||
return len;
|
||||
}
|
||||
|
||||
esp_err_t jpg_httpd_handler(httpd_req_t *req){
|
||||
camera_fb_t * fb = NULL;
|
||||
esp_err_t res = ESP_OK;
|
||||
size_t fb_len = 0;
|
||||
int64_t fr_start = esp_timer_get_time();
|
||||
|
||||
fb = esp_camera_fb_get();
|
||||
if (!fb) {
|
||||
ESP_LOGE(TAG, "Camera capture failed");
|
||||
httpd_resp_send_500(req);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
res = httpd_resp_set_type(req, "image/jpeg");
|
||||
if(res == ESP_OK){
|
||||
res = httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.jpg");
|
||||
}
|
||||
|
||||
if(res == ESP_OK){
|
||||
if(fb->format == PIXFORMAT_JPEG){
|
||||
fb_len = fb->len;
|
||||
res = httpd_resp_send(req, (const char *)fb->buf, fb->len);
|
||||
} else {
|
||||
jpg_chunking_t jchunk = {req, 0};
|
||||
res = frame2jpg_cb(fb, 80, jpg_encode_stream, &jchunk)?ESP_OK:ESP_FAIL;
|
||||
httpd_resp_send_chunk(req, NULL, 0);
|
||||
fb_len = jchunk.len;
|
||||
}
|
||||
}
|
||||
esp_camera_fb_return(fb);
|
||||
int64_t fr_end = esp_timer_get_time();
|
||||
ESP_LOGI(TAG, "JPG: %uKB %ums", (uint32_t)(fb_len/1024), (uint32_t)((fr_end - fr_start)/1000));
|
||||
return res;
|
||||
}
|
||||
```
|
||||
|
||||
### JPEG HTTP Stream
|
||||
|
||||
```c
|
||||
#include "esp_camera.h"
|
||||
#include "esp_http_server.h"
|
||||
#include "esp_timer.h"
|
||||
|
||||
#define PART_BOUNDARY "123456789000000000000987654321"
|
||||
static const char* _STREAM_CONTENT_TYPE = "multipart/x-mixed-replace;boundary=" PART_BOUNDARY;
|
||||
static const char* _STREAM_BOUNDARY = "\r\n--" PART_BOUNDARY "\r\n";
|
||||
static const char* _STREAM_PART = "Content-Type: image/jpeg\r\nContent-Length: %u\r\n\r\n";
|
||||
|
||||
esp_err_t jpg_stream_httpd_handler(httpd_req_t *req){
|
||||
camera_fb_t * fb = NULL;
|
||||
esp_err_t res = ESP_OK;
|
||||
size_t _jpg_buf_len;
|
||||
uint8_t * _jpg_buf;
|
||||
char * part_buf[64];
|
||||
static int64_t last_frame = 0;
|
||||
if(!last_frame) {
|
||||
last_frame = esp_timer_get_time();
|
||||
}
|
||||
|
||||
res = httpd_resp_set_type(req, _STREAM_CONTENT_TYPE);
|
||||
if(res != ESP_OK){
|
||||
return res;
|
||||
}
|
||||
|
||||
while(true){
|
||||
fb = esp_camera_fb_get();
|
||||
if (!fb) {
|
||||
ESP_LOGE(TAG, "Camera capture failed");
|
||||
res = ESP_FAIL;
|
||||
break;
|
||||
}
|
||||
if(fb->format != PIXFORMAT_JPEG){
|
||||
bool jpeg_converted = frame2jpg(fb, 80, &_jpg_buf, &_jpg_buf_len);
|
||||
if(!jpeg_converted){
|
||||
ESP_LOGE(TAG, "JPEG compression failed");
|
||||
esp_camera_fb_return(fb);
|
||||
res = ESP_FAIL;
|
||||
}
|
||||
} else {
|
||||
_jpg_buf_len = fb->len;
|
||||
_jpg_buf = fb->buf;
|
||||
}
|
||||
|
||||
if(res == ESP_OK){
|
||||
res = httpd_resp_send_chunk(req, _STREAM_BOUNDARY, strlen(_STREAM_BOUNDARY));
|
||||
}
|
||||
if(res == ESP_OK){
|
||||
size_t hlen = snprintf((char *)part_buf, 64, _STREAM_PART, _jpg_buf_len);
|
||||
|
||||
res = httpd_resp_send_chunk(req, (const char *)part_buf, hlen);
|
||||
}
|
||||
if(res == ESP_OK){
|
||||
res = httpd_resp_send_chunk(req, (const char *)_jpg_buf, _jpg_buf_len);
|
||||
}
|
||||
if(fb->format != PIXFORMAT_JPEG){
|
||||
free(_jpg_buf);
|
||||
}
|
||||
esp_camera_fb_return(fb);
|
||||
if(res != ESP_OK){
|
||||
break;
|
||||
}
|
||||
int64_t fr_end = esp_timer_get_time();
|
||||
int64_t frame_time = fr_end - last_frame;
|
||||
last_frame = fr_end;
|
||||
frame_time /= 1000;
|
||||
ESP_LOGI(TAG, "MJPG: %uKB %ums (%.1ffps)",
|
||||
(uint32_t)(_jpg_buf_len/1024),
|
||||
(uint32_t)frame_time, 1000.0 / (uint32_t)frame_time);
|
||||
}
|
||||
|
||||
last_frame = 0;
|
||||
return res;
|
||||
}
|
||||
```
|
||||
|
||||
### BMP HTTP Capture
|
||||
|
||||
```c
|
||||
#include "esp_camera.h"
|
||||
#include "esp_http_server.h"
|
||||
#include "esp_timer.h"
|
||||
|
||||
esp_err_t bmp_httpd_handler(httpd_req_t *req){
|
||||
camera_fb_t * fb = NULL;
|
||||
esp_err_t res = ESP_OK;
|
||||
int64_t fr_start = esp_timer_get_time();
|
||||
|
||||
fb = esp_camera_fb_get();
|
||||
if (!fb) {
|
||||
ESP_LOGE(TAG, "Camera capture failed");
|
||||
httpd_resp_send_500(req);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
uint8_t * buf = NULL;
|
||||
size_t buf_len = 0;
|
||||
bool converted = frame2bmp(fb, &buf, &buf_len);
|
||||
esp_camera_fb_return(fb);
|
||||
if(!converted){
|
||||
ESP_LOGE(TAG, "BMP conversion failed");
|
||||
httpd_resp_send_500(req);
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
res = httpd_resp_set_type(req, "image/x-windows-bmp")
|
||||
|| httpd_resp_set_hdr(req, "Content-Disposition", "inline; filename=capture.bmp")
|
||||
|| httpd_resp_send(req, (const char *)buf, buf_len);
|
||||
free(buf);
|
||||
int64_t fr_end = esp_timer_get_time();
|
||||
ESP_LOGI(TAG, "BMP: %uKB %ums", (uint32_t)(buf_len/1024), (uint32_t)((fr_end - fr_start)/1000));
|
||||
return res;
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
|
||||
|
|
@ -1,214 +0,0 @@
|
|||
// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS,
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
/*
|
||||
* Example Use
|
||||
*
|
||||
static camera_config_t camera_example_config = {
|
||||
.pin_pwdn = PIN_PWDN,
|
||||
.pin_reset = PIN_RESET,
|
||||
.pin_xclk = PIN_XCLK,
|
||||
.pin_sscb_sda = PIN_SIOD,
|
||||
.pin_sscb_scl = PIN_SIOC,
|
||||
.pin_d7 = PIN_D7,
|
||||
.pin_d6 = PIN_D6,
|
||||
.pin_d5 = PIN_D5,
|
||||
.pin_d4 = PIN_D4,
|
||||
.pin_d3 = PIN_D3,
|
||||
.pin_d2 = PIN_D2,
|
||||
.pin_d1 = PIN_D1,
|
||||
.pin_d0 = PIN_D0,
|
||||
.pin_vsync = PIN_VSYNC,
|
||||
.pin_href = PIN_HREF,
|
||||
.pin_pclk = PIN_PCLK,
|
||||
|
||||
.xclk_freq_hz = 20000000,
|
||||
.ledc_timer = LEDC_TIMER_0,
|
||||
.ledc_channel = LEDC_CHANNEL_0,
|
||||
.pixel_format = PIXFORMAT_JPEG,
|
||||
.frame_size = FRAMESIZE_SVGA,
|
||||
.jpeg_quality = 10,
|
||||
.fb_count = 2,
|
||||
.grab_mode = CAMERA_GRAB_WHEN_EMPTY
|
||||
};
|
||||
|
||||
esp_err_t camera_example_init(){
|
||||
return esp_camera_init(&camera_example_config);
|
||||
}
|
||||
|
||||
esp_err_t camera_example_capture(){
|
||||
//capture a frame
|
||||
camera_fb_t * fb = esp_camera_fb_get();
|
||||
if (!fb) {
|
||||
ESP_LOGE(TAG, "Frame buffer could not be acquired");
|
||||
return ESP_FAIL;
|
||||
}
|
||||
|
||||
//replace this with your own function
|
||||
display_image(fb->width, fb->height, fb->pixformat, fb->buf, fb->len);
|
||||
|
||||
//return the frame buffer back to be reused
|
||||
esp_camera_fb_return(fb);
|
||||
|
||||
return ESP_OK;
|
||||
}
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include "esp_err.h"
|
||||
#include "driver/ledc.h"
|
||||
#include "sensor.h"
|
||||
#include "sys/time.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Configuration structure for camera initialization
|
||||
*/
|
||||
typedef enum {
|
||||
CAMERA_GRAB_WHEN_EMPTY, /*!< Fills buffers when they are empty. Less resources but first 'fb_count' frames might be old */
|
||||
CAMERA_GRAB_LATEST /*!< Except when 1 frame buffer is used, queue will always contain the last 'fb_count' frames */
|
||||
} camera_grab_mode_t;
|
||||
|
||||
/**
|
||||
* @brief Camera frame buffer location
|
||||
*/
|
||||
typedef enum {
|
||||
CAMERA_FB_IN_PSRAM, /*!< Frame buffer is placed in external PSRAM */
|
||||
CAMERA_FB_IN_DRAM /*!< Frame buffer is placed in internal DRAM */
|
||||
} camera_fb_location_t;
|
||||
|
||||
/**
|
||||
* @brief Configuration structure for camera initialization
|
||||
*/
|
||||
typedef struct {
|
||||
int pin_pwdn; /*!< GPIO pin for camera power down line */
|
||||
int pin_reset; /*!< GPIO pin for camera reset line */
|
||||
int pin_xclk; /*!< GPIO pin for camera XCLK line */
|
||||
int pin_sscb_sda; /*!< GPIO pin for camera SDA line */
|
||||
int pin_sscb_scl; /*!< GPIO pin for camera SCL line */
|
||||
int pin_d7; /*!< GPIO pin for camera D7 line */
|
||||
int pin_d6; /*!< GPIO pin for camera D6 line */
|
||||
int pin_d5; /*!< GPIO pin for camera D5 line */
|
||||
int pin_d4; /*!< GPIO pin for camera D4 line */
|
||||
int pin_d3; /*!< GPIO pin for camera D3 line */
|
||||
int pin_d2; /*!< GPIO pin for camera D2 line */
|
||||
int pin_d1; /*!< GPIO pin for camera D1 line */
|
||||
int pin_d0; /*!< GPIO pin for camera D0 line */
|
||||
int pin_vsync; /*!< GPIO pin for camera VSYNC line */
|
||||
int pin_href; /*!< GPIO pin for camera HREF line */
|
||||
int pin_pclk; /*!< GPIO pin for camera PCLK line */
|
||||
|
||||
int xclk_freq_hz; /*!< Frequency of XCLK signal, in Hz. EXPERIMENTAL: Set to 16MHz on ESP32-S2 or ESP32-S3 to enable EDMA mode */
|
||||
|
||||
ledc_timer_t ledc_timer; /*!< LEDC timer to be used for generating XCLK */
|
||||
ledc_channel_t ledc_channel; /*!< LEDC channel to be used for generating XCLK */
|
||||
|
||||
pixformat_t pixel_format; /*!< Format of the pixel data: PIXFORMAT_ + YUV422|GRAYSCALE|RGB565|JPEG */
|
||||
framesize_t frame_size; /*!< Size of the output image: FRAMESIZE_ + QVGA|CIF|VGA|SVGA|XGA|SXGA|UXGA */
|
||||
|
||||
int jpeg_quality; /*!< Quality of JPEG output. 0-63 lower means higher quality */
|
||||
size_t fb_count; /*!< Number of frame buffers to be allocated. If more than one, then each frame will be acquired (double speed) */
|
||||
camera_fb_location_t fb_location; /*!< The location where the frame buffer will be allocated */
|
||||
camera_grab_mode_t grab_mode; /*!< When buffers should be filled */
|
||||
} camera_config_t;
|
||||
|
||||
/**
|
||||
* @brief Data structure of camera frame buffer
|
||||
*/
|
||||
typedef struct {
|
||||
uint8_t * buf; /*!< Pointer to the pixel data */
|
||||
size_t len; /*!< Length of the buffer in bytes */
|
||||
size_t width; /*!< Width of the buffer in pixels */
|
||||
size_t height; /*!< Height of the buffer in pixels */
|
||||
pixformat_t format; /*!< Format of the pixel data */
|
||||
struct timeval timestamp; /*!< Timestamp since boot of the first DMA buffer of the frame */
|
||||
} camera_fb_t;
|
||||
|
||||
#define ESP_ERR_CAMERA_BASE 0x20000
|
||||
#define ESP_ERR_CAMERA_NOT_DETECTED (ESP_ERR_CAMERA_BASE + 1)
|
||||
#define ESP_ERR_CAMERA_FAILED_TO_SET_FRAME_SIZE (ESP_ERR_CAMERA_BASE + 2)
|
||||
#define ESP_ERR_CAMERA_FAILED_TO_SET_OUT_FORMAT (ESP_ERR_CAMERA_BASE + 3)
|
||||
#define ESP_ERR_CAMERA_NOT_SUPPORTED (ESP_ERR_CAMERA_BASE + 4)
|
||||
|
||||
/**
|
||||
* @brief Initialize the camera driver
|
||||
*
|
||||
* @note call camera_probe before calling this function
|
||||
*
|
||||
* This function detects and configures camera over I2C interface,
|
||||
* allocates framebuffer and DMA buffers,
|
||||
* initializes parallel I2S input, and sets up DMA descriptors.
|
||||
*
|
||||
* Currently this function can only be called once and there is
|
||||
* no way to de-initialize this module.
|
||||
*
|
||||
* @param config Camera configuration parameters
|
||||
*
|
||||
* @return ESP_OK on success
|
||||
*/
|
||||
esp_err_t esp_camera_init(const camera_config_t* config);
|
||||
|
||||
/**
|
||||
* @brief Deinitialize the camera driver
|
||||
*
|
||||
* @return
|
||||
* - ESP_OK on success
|
||||
* - ESP_ERR_INVALID_STATE if the driver hasn't been initialized yet
|
||||
*/
|
||||
esp_err_t esp_camera_deinit();
|
||||
|
||||
/**
|
||||
* @brief Obtain pointer to a frame buffer.
|
||||
*
|
||||
* @return pointer to the frame buffer
|
||||
*/
|
||||
camera_fb_t* esp_camera_fb_get();
|
||||
|
||||
/**
|
||||
* @brief Return the frame buffer to be reused again.
|
||||
*
|
||||
* @param fb Pointer to the frame buffer
|
||||
*/
|
||||
void esp_camera_fb_return(camera_fb_t * fb);
|
||||
|
||||
/**
|
||||
* @brief Get a pointer to the image sensor control structure
|
||||
*
|
||||
* @return pointer to the sensor
|
||||
*/
|
||||
sensor_t * esp_camera_sensor_get();
|
||||
|
||||
/**
|
||||
* @brief Save camera settings to non-volatile-storage (NVS)
|
||||
*
|
||||
* @param key A unique nvs key name for the camera settings
|
||||
*/
|
||||
esp_err_t esp_camera_save_to_nvs(const char *key);
|
||||
|
||||
/**
|
||||
* @brief Load camera settings from non-volatile-storage (NVS)
|
||||
*
|
||||
* @param key A unique nvs key name for the camera settings
|
||||
*/
|
||||
esp_err_t esp_camera_load_from_nvs(const char *key);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#include "img_converters.h"
|
||||
|
||||
|
|
@ -1,245 +0,0 @@
|
|||
/*
|
||||
* This file is part of the OpenMV project.
|
||||
* Copyright (c) 2013/2014 Ibrahim Abdelkader <i.abdalkader@gmail.com>
|
||||
* This work is licensed under the MIT license, see the file LICENSE for details.
|
||||
*
|
||||
* Sensor abstraction layer.
|
||||
*
|
||||
*/
|
||||
#ifndef __SENSOR_H__
|
||||
#define __SENSOR_H__
|
||||
#include <stdint.h>
|
||||
#include <stdbool.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum {
|
||||
OV9650_PID = 0x96,
|
||||
OV7725_PID = 0x77,
|
||||
OV2640_PID = 0x26,
|
||||
OV3660_PID = 0x3660,
|
||||
OV5640_PID = 0x5640,
|
||||
OV7670_PID = 0x76,
|
||||
NT99141_PID = 0x1410,
|
||||
GC2145_PID = 0x2145,
|
||||
GC032A_PID = 0x232a,
|
||||
GC0308_PID = 0x9b,
|
||||
} camera_pid_t;
|
||||
|
||||
typedef enum {
|
||||
CAMERA_OV7725,
|
||||
CAMERA_OV2640,
|
||||
CAMERA_OV3660,
|
||||
CAMERA_OV5640,
|
||||
CAMERA_OV7670,
|
||||
CAMERA_NT99141,
|
||||
CAMERA_GC2145,
|
||||
CAMERA_GC032A,
|
||||
CAMERA_GC0308,
|
||||
CAMERA_MODEL_MAX,
|
||||
CAMERA_NONE,
|
||||
} camera_model_t;
|
||||
|
||||
typedef enum {
|
||||
OV2640_SCCB_ADDR = 0x30,// 0x60 >> 1
|
||||
OV5640_SCCB_ADDR = 0x3C,// 0x78 >> 1
|
||||
OV3660_SCCB_ADDR = 0x3C,// 0x78 >> 1
|
||||
OV7725_SCCB_ADDR = 0x21,// 0x42 >> 1
|
||||
OV7670_SCCB_ADDR = 0x21,// 0x42 >> 1
|
||||
NT99141_SCCB_ADDR = 0x2A,// 0x54 >> 1
|
||||
GC2145_SCCB_ADDR = 0x3C,// 0x78 >> 1
|
||||
GC032A_SCCB_ADDR = 0x21,// 0x42 >> 1
|
||||
GC0308_SCCB_ADDR = 0x21,// 0x42 >> 1
|
||||
} camera_sccb_addr_t;
|
||||
|
||||
typedef enum {
|
||||
PIXFORMAT_RGB565, // 2BPP/RGB565
|
||||
PIXFORMAT_YUV422, // 2BPP/YUV422
|
||||
PIXFORMAT_GRAYSCALE, // 1BPP/GRAYSCALE
|
||||
PIXFORMAT_JPEG, // JPEG/COMPRESSED
|
||||
PIXFORMAT_RGB888, // 3BPP/RGB888
|
||||
PIXFORMAT_RAW, // RAW
|
||||
PIXFORMAT_RGB444, // 3BP2P/RGB444
|
||||
PIXFORMAT_RGB555, // 3BP2P/RGB555
|
||||
} pixformat_t;
|
||||
|
||||
typedef enum {
|
||||
FRAMESIZE_96X96, // 96x96
|
||||
FRAMESIZE_QQVGA, // 160x120
|
||||
FRAMESIZE_QCIF, // 176x144
|
||||
FRAMESIZE_HQVGA, // 240x176
|
||||
FRAMESIZE_240X240, // 240x240
|
||||
FRAMESIZE_QVGA, // 320x240
|
||||
FRAMESIZE_CIF, // 400x296
|
||||
FRAMESIZE_HVGA, // 480x320
|
||||
FRAMESIZE_VGA, // 640x480
|
||||
FRAMESIZE_SVGA, // 800x600
|
||||
FRAMESIZE_XGA, // 1024x768
|
||||
FRAMESIZE_HD, // 1280x720
|
||||
FRAMESIZE_SXGA, // 1280x1024
|
||||
FRAMESIZE_UXGA, // 1600x1200
|
||||
// 3MP Sensors
|
||||
FRAMESIZE_FHD, // 1920x1080
|
||||
FRAMESIZE_P_HD, // 720x1280
|
||||
FRAMESIZE_P_3MP, // 864x1536
|
||||
FRAMESIZE_QXGA, // 2048x1536
|
||||
// 5MP Sensors
|
||||
FRAMESIZE_QHD, // 2560x1440
|
||||
FRAMESIZE_WQXGA, // 2560x1600
|
||||
FRAMESIZE_P_FHD, // 1080x1920
|
||||
FRAMESIZE_QSXGA, // 2560x1920
|
||||
FRAMESIZE_INVALID
|
||||
} framesize_t;
|
||||
|
||||
typedef struct {
|
||||
const camera_model_t model;
|
||||
const char *name;
|
||||
const camera_sccb_addr_t sccb_addr;
|
||||
const camera_pid_t pid;
|
||||
const framesize_t max_size;
|
||||
const bool support_jpeg;
|
||||
} camera_sensor_info_t;
|
||||
|
||||
typedef enum {
|
||||
ASPECT_RATIO_4X3,
|
||||
ASPECT_RATIO_3X2,
|
||||
ASPECT_RATIO_16X10,
|
||||
ASPECT_RATIO_5X3,
|
||||
ASPECT_RATIO_16X9,
|
||||
ASPECT_RATIO_21X9,
|
||||
ASPECT_RATIO_5X4,
|
||||
ASPECT_RATIO_1X1,
|
||||
ASPECT_RATIO_9X16
|
||||
} aspect_ratio_t;
|
||||
|
||||
typedef enum {
|
||||
GAINCEILING_2X,
|
||||
GAINCEILING_4X,
|
||||
GAINCEILING_8X,
|
||||
GAINCEILING_16X,
|
||||
GAINCEILING_32X,
|
||||
GAINCEILING_64X,
|
||||
GAINCEILING_128X,
|
||||
} gainceiling_t;
|
||||
|
||||
typedef struct {
|
||||
uint16_t max_width;
|
||||
uint16_t max_height;
|
||||
uint16_t start_x;
|
||||
uint16_t start_y;
|
||||
uint16_t end_x;
|
||||
uint16_t end_y;
|
||||
uint16_t offset_x;
|
||||
uint16_t offset_y;
|
||||
uint16_t total_x;
|
||||
uint16_t total_y;
|
||||
} ratio_settings_t;
|
||||
|
||||
typedef struct {
|
||||
const uint16_t width;
|
||||
const uint16_t height;
|
||||
const aspect_ratio_t aspect_ratio;
|
||||
} resolution_info_t;
|
||||
|
||||
// Resolution table (in sensor.c)
|
||||
extern const resolution_info_t resolution[];
|
||||
// camera sensor table (in sensor.c)
|
||||
extern const camera_sensor_info_t camera_sensor[];
|
||||
|
||||
typedef struct {
|
||||
uint8_t MIDH;
|
||||
uint8_t MIDL;
|
||||
uint16_t PID;
|
||||
uint8_t VER;
|
||||
} sensor_id_t;
|
||||
|
||||
typedef struct {
|
||||
framesize_t framesize;//0 - 10
|
||||
bool scale;
|
||||
bool binning;
|
||||
uint8_t quality;//0 - 63
|
||||
int8_t brightness;//-2 - 2
|
||||
int8_t contrast;//-2 - 2
|
||||
int8_t saturation;//-2 - 2
|
||||
int8_t sharpness;//-2 - 2
|
||||
uint8_t denoise;
|
||||
uint8_t special_effect;//0 - 6
|
||||
uint8_t wb_mode;//0 - 4
|
||||
uint8_t awb;
|
||||
uint8_t awb_gain;
|
||||
uint8_t aec;
|
||||
uint8_t aec2;
|
||||
int8_t ae_level;//-2 - 2
|
||||
uint16_t aec_value;//0 - 1200
|
||||
uint8_t agc;
|
||||
uint8_t agc_gain;//0 - 30
|
||||
uint8_t gainceiling;//0 - 6
|
||||
uint8_t bpc;
|
||||
uint8_t wpc;
|
||||
uint8_t raw_gma;
|
||||
uint8_t lenc;
|
||||
uint8_t hmirror;
|
||||
uint8_t vflip;
|
||||
uint8_t dcw;
|
||||
uint8_t colorbar;
|
||||
} camera_status_t;
|
||||
|
||||
typedef struct _sensor sensor_t;
|
||||
typedef struct _sensor {
|
||||
sensor_id_t id; // Sensor ID.
|
||||
uint8_t slv_addr; // Sensor I2C slave address.
|
||||
pixformat_t pixformat;
|
||||
camera_status_t status;
|
||||
int xclk_freq_hz;
|
||||
|
||||
// Sensor function pointers
|
||||
int (*init_status) (sensor_t *sensor);
|
||||
int (*reset) (sensor_t *sensor);
|
||||
int (*set_pixformat) (sensor_t *sensor, pixformat_t pixformat);
|
||||
int (*set_framesize) (sensor_t *sensor, framesize_t framesize);
|
||||
int (*set_contrast) (sensor_t *sensor, int level);
|
||||
int (*set_brightness) (sensor_t *sensor, int level);
|
||||
int (*set_saturation) (sensor_t *sensor, int level);
|
||||
int (*set_sharpness) (sensor_t *sensor, int level);
|
||||
int (*set_denoise) (sensor_t *sensor, int level);
|
||||
int (*set_gainceiling) (sensor_t *sensor, gainceiling_t gainceiling);
|
||||
int (*set_quality) (sensor_t *sensor, int quality);
|
||||
int (*set_colorbar) (sensor_t *sensor, int enable);
|
||||
int (*set_whitebal) (sensor_t *sensor, int enable);
|
||||
int (*set_gain_ctrl) (sensor_t *sensor, int enable);
|
||||
int (*set_exposure_ctrl) (sensor_t *sensor, int enable);
|
||||
int (*set_hmirror) (sensor_t *sensor, int enable);
|
||||
int (*set_vflip) (sensor_t *sensor, int enable);
|
||||
|
||||
int (*set_aec2) (sensor_t *sensor, int enable);
|
||||
int (*set_awb_gain) (sensor_t *sensor, int enable);
|
||||
int (*set_agc_gain) (sensor_t *sensor, int gain);
|
||||
int (*set_aec_value) (sensor_t *sensor, int gain);
|
||||
|
||||
int (*set_special_effect) (sensor_t *sensor, int effect);
|
||||
int (*set_wb_mode) (sensor_t *sensor, int mode);
|
||||
int (*set_ae_level) (sensor_t *sensor, int level);
|
||||
|
||||
int (*set_dcw) (sensor_t *sensor, int enable);
|
||||
int (*set_bpc) (sensor_t *sensor, int enable);
|
||||
int (*set_wpc) (sensor_t *sensor, int enable);
|
||||
|
||||
int (*set_raw_gma) (sensor_t *sensor, int enable);
|
||||
int (*set_lenc) (sensor_t *sensor, int enable);
|
||||
|
||||
int (*get_reg) (sensor_t *sensor, int reg, int mask);
|
||||
int (*set_reg) (sensor_t *sensor, int reg, int mask, int value);
|
||||
int (*set_res_raw) (sensor_t *sensor, int startX, int startY, int endX, int endY, int offsetX, int offsetY, int totalX, int totalY, int outputX, int outputY, bool scale, bool binning);
|
||||
int (*set_pll) (sensor_t *sensor, int bypass, int mul, int sys, int root, int pre, int seld5, int pclken, int pclk);
|
||||
int (*set_xclk) (sensor_t *sensor, int timer, int xclk);
|
||||
} sensor_t;
|
||||
|
||||
camera_sensor_info_t *esp_camera_sensor_get_info(sensor_id_t *id);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* __SENSOR_H__ */
|
||||
|
|
@ -1,9 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#include "esp_system.h"
|
||||
|
||||
esp_err_t xclk_timer_conf(int ledc_timer, int xclk_freq_hz);
|
||||
|
||||
esp_err_t camera_enable_out_clock();
|
||||
|
||||
void camera_disable_out_clock();
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
{
|
||||
"name": "esp32-camera-header",
|
||||
"version": "1.0.0",
|
||||
"keywords": "esp32, camera, espressif, esp32-cam",
|
||||
"description": "ESP32 camera header files",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "https://github.com/espressif/esp32-camera"
|
||||
},
|
||||
"frameworks": "arduino",
|
||||
"platforms": "espressif32",
|
||||
"build": {
|
||||
"flags": [
|
||||
"-Idriver/include"
|
||||
],
|
||||
"includeDir": ".",
|
||||
"srcDir": ".",
|
||||
"srcFilter": ["-<*>", "+<driver>"]
|
||||
}
|
||||
}
|
||||
|
|
@ -899,7 +899,7 @@ const be_ntv_func_def_t lv_label_func[] = {
|
|||
{ "get_letter_pos", { (const void*) &lv_label_get_letter_pos, "", "(lv.lv_obj)i(lv.lv_point)" } },
|
||||
{ "get_long_mode", { (const void*) &lv_label_get_long_mode, "i", "(lv.lv_obj)" } },
|
||||
{ "get_recolor", { (const void*) &lv_label_get_recolor, "b", "(lv.lv_obj)" } },
|
||||
{ "get_text", { (const void*) &lv_label_get_text, "c", "(lv.lv_obj)" } },
|
||||
{ "get_text", { (const void*) &lv_label_get_text, "s", "(lv.lv_obj)" } },
|
||||
{ "get_text_selection_end", { (const void*) &lv_label_get_text_selection_end, "i", "(lv.lv_obj)" } },
|
||||
{ "get_text_selection_start", { (const void*) &lv_label_get_text_selection_start, "i", "(lv.lv_obj)" } },
|
||||
{ "ins_text", { (const void*) &lv_label_ins_text, "", "(lv.lv_obj)is" } },
|
||||
|
|
|
|||
|
|
@ -38,6 +38,7 @@ return_types = {
|
|||
"char *": "c",
|
||||
"uint8_t *": "c",
|
||||
"const char *": "s",
|
||||
"retchar *": "s",
|
||||
"constchar *": "s", # special construct
|
||||
"lv_obj_user_data_t": "i",
|
||||
|
||||
|
|
@ -245,6 +246,7 @@ with open(lv_widgets_file) as f:
|
|||
l_raw = re.sub('static ', '', l_raw)
|
||||
l_raw = re.sub('inline ', '', l_raw)
|
||||
l_raw = re.sub('const\s+char\s*\*', 'constchar *', l_raw)
|
||||
l_raw = re.sub('^char\s*\*', 'retchar *', l_raw) # special case for returning a char*
|
||||
l_raw = re.sub('const ', '', l_raw)
|
||||
l_raw = re.sub('struct ', '', l_raw)
|
||||
if (len(l_raw) == 0): continue
|
||||
|
|
|
|||
|
|
@ -67,7 +67,6 @@ lib_ignore = ESP8266Audio
|
|||
TTGO TWatch Library
|
||||
Micro-RTSP
|
||||
epdiy
|
||||
esp32-camera
|
||||
|
||||
[env:tasmota32c3-mi32-homebridge]
|
||||
extends = env:tasmota32c3
|
||||
|
|
@ -81,7 +80,6 @@ lib_ignore = ESP8266Audio
|
|||
TTGO TWatch Library
|
||||
Micro-RTSP
|
||||
epdiy
|
||||
esp32-camera
|
||||
|
||||
[env:tasmota32s3-mi32-homebridge]
|
||||
extends = env:tasmota32s3
|
||||
|
|
@ -95,7 +93,6 @@ lib_ignore = ESP8266Audio
|
|||
TTGO TWatch Library
|
||||
Micro-RTSP
|
||||
epdiy
|
||||
esp32-camera
|
||||
|
||||
; *** Debug version used for PlatformIO Home Project Inspection
|
||||
[env:tasmota-debug]
|
||||
|
|
|
|||
|
|
@ -303,6 +303,7 @@ const uint32_t LOOP_SLEEP_DELAY = 50; // Lowest number of milliseconds to
|
|||
#define XPT2046_MAXX 3895
|
||||
#define XPT2046_MINY 346
|
||||
#define XPT2046_MAXY 3870
|
||||
|
||||
/*********************************************************************************************\
|
||||
* Enumeration
|
||||
\*********************************************************************************************/
|
||||
|
|
|
|||
|
|
@ -446,6 +446,7 @@ const char kSensorNames[] PROGMEM =
|
|||
const char kSensorNamesFixed[] PROGMEM =
|
||||
D_SENSOR_USER;
|
||||
|
||||
// Max number of GPIOs
|
||||
#define MAX_MAX31865S 6
|
||||
#define MAX_FLOWRATEMETER 2
|
||||
#define MAX_A4988_MSS 3
|
||||
|
|
@ -453,6 +454,7 @@ const char kSensorNamesFixed[] PROGMEM =
|
|||
#define MAX_WEBCAM_HSD 3
|
||||
#define MAX_SM2135_DAT 10
|
||||
#define MAX_SM2335_DAT 16
|
||||
#define MAX_DSB 4
|
||||
|
||||
const uint16_t kGpioNiceList[] PROGMEM = {
|
||||
GPIO_NONE, // Not used
|
||||
|
|
@ -661,9 +663,11 @@ const uint16_t kGpioNiceList[] PROGMEM = {
|
|||
AGPIO(GPIO_DHT11_OUT), // Pseudo Single wire DHT11, DHT21, DHT22, AM2301, AM2302, AM2321
|
||||
#endif
|
||||
#ifdef USE_DS18x20
|
||||
AGPIO(GPIO_DSB), // Single wire DS18B20 or DS18S20
|
||||
AGPIO(GPIO_DSB_OUT), // Pseudo Single wire DS18B20 or DS18S20
|
||||
#endif
|
||||
AGPIO(GPIO_DSB) + MAX_DSB, // Single wire DS18B20 or DS18S20
|
||||
#ifdef ESP8266
|
||||
AGPIO(GPIO_DSB_OUT) + MAX_DSB, // Pseudo Single wire DS18B20 or DS18S20
|
||||
#endif // ESP8266
|
||||
#endif // USE_DS18x20
|
||||
#ifdef USE_LMT01
|
||||
AGPIO(GPIO_LMT01), // LMT01, count pulses on GPIO
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -579,7 +579,7 @@
|
|||
// -- One wire sensors ----------------------------
|
||||
#define USE_DS18x20 // Add support for DS18x20 sensors with id sort, single scan and read retry (+2k6 code)
|
||||
// #define W1_PARASITE_POWER // Optimize for parasite powered sensors
|
||||
// #define DS18x20_USE_ID_ALIAS
|
||||
// #define DS18x20_USE_ID_ALIAS // Add support aliasing for DS18x20 sensors. See comments in xsns_05 files (+0k5 code)
|
||||
|
||||
// -- I2C sensors ---------------------------------
|
||||
#define USE_I2C // I2C using library wire (+10k code, 0k2 mem, 124 iram)
|
||||
|
|
|
|||
|
|
@ -158,6 +158,7 @@ RTC_NOINIT_ATTR TRtcSettings RtcDataSettings;
|
|||
#endif // ESP32
|
||||
|
||||
struct TIME_T {
|
||||
uint32_t nanos;
|
||||
uint8_t second;
|
||||
uint8_t minute;
|
||||
uint8_t hour;
|
||||
|
|
|
|||
|
|
@ -43,10 +43,12 @@ struct RTC {
|
|||
uint32_t standard_time = 0;
|
||||
uint32_t midnight = 0;
|
||||
uint32_t restart_time = 0;
|
||||
uint32_t nanos = 0;
|
||||
uint32_t millis = 0;
|
||||
// uint32_t last_sync = 0;
|
||||
int32_t time_timezone = 0;
|
||||
bool time_synced = false;
|
||||
bool last_synced = false;
|
||||
bool midnight_now = false;
|
||||
bool user_time_entry = false; // Override NTP by user setting
|
||||
} Rtc;
|
||||
|
|
@ -235,11 +237,14 @@ uint32_t RtcMillis(void) {
|
|||
return (millis() - Rtc.millis) % 1000;
|
||||
}
|
||||
|
||||
void BreakTime(uint32_t time_input, TIME_T &tm) {
|
||||
void BreakNanoTime(uint32_t time_input, uint32_t time_nanos, TIME_T &tm) {
|
||||
// break the given time_input into time components
|
||||
// this is a more compact version of the C library localtime function
|
||||
// note that year is offset from 1970 !!!
|
||||
|
||||
time_input += time_nanos / 1000000000U;
|
||||
tm.nanos = time_nanos % 1000000000U;
|
||||
|
||||
uint8_t year;
|
||||
uint8_t month;
|
||||
uint8_t month_length;
|
||||
|
|
@ -290,6 +295,10 @@ void BreakTime(uint32_t time_input, TIME_T &tm) {
|
|||
tm.valid = (time_input > START_VALID_TIME); // 2016-01-01
|
||||
}
|
||||
|
||||
void BreakTime(uint32_t time_input, TIME_T &tm) {
|
||||
BreakNanoTime(time_input, 0, tm);
|
||||
}
|
||||
|
||||
uint32_t MakeTime(TIME_T &tm) {
|
||||
// assemble time elements into time_t
|
||||
// note year argument is offset from 1970
|
||||
|
|
@ -403,6 +412,7 @@ void RtcSecond(void) {
|
|||
mutex = true;
|
||||
|
||||
Rtc.time_synced = false;
|
||||
Rtc.last_synced = true;
|
||||
last_sync = Rtc.utc_time;
|
||||
|
||||
if (Rtc.restart_time == 0) {
|
||||
|
|
@ -420,7 +430,13 @@ void RtcSecond(void) {
|
|||
TasmotaGlobal.rules_flag.time_set = 1;
|
||||
}
|
||||
} else {
|
||||
Rtc.utc_time++; // Increment every second
|
||||
if (Rtc.last_synced) {
|
||||
Rtc.last_synced = false;
|
||||
uint32_t nanos = Rtc.nanos + (millis() - Rtc.millis) * 1000000U;
|
||||
Rtc.utc_time += nanos / 1000000000U;
|
||||
Rtc.nanos = nanos % 1000000000U;
|
||||
} else
|
||||
Rtc.utc_time++; // Increment every second
|
||||
}
|
||||
Rtc.millis = millis();
|
||||
|
||||
|
|
@ -442,7 +458,7 @@ void RtcSecond(void) {
|
|||
}
|
||||
}
|
||||
|
||||
BreakTime(Rtc.local_time, RtcTime);
|
||||
BreakNanoTime(Rtc.local_time, Rtc.nanos, RtcTime);
|
||||
if (RtcTime.valid) {
|
||||
if (!Rtc.midnight) {
|
||||
Rtc.midnight = Rtc.local_time - (RtcTime.hour * 3600) - (RtcTime.minute * 60) - RtcTime.second;
|
||||
|
|
|
|||
|
|
@ -878,13 +878,15 @@ void WifiPollNtp() {
|
|||
|
||||
AddLog(LOG_LEVEL_DEBUG_MORE, PSTR("NTP: Sync time..."));
|
||||
ntp_run_time = millis();
|
||||
uint32_t ntp_time = WifiGetNtp();
|
||||
uint64_t ntp_nanos = WifiGetNtp();
|
||||
uint32_t ntp_time = ntp_nanos / 1000000000;
|
||||
ntp_run_time = (millis() - ntp_run_time) / 1000;
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("NTP: Runtime %d"), ntp_run_time);
|
||||
if (ntp_run_time < 5) { ntp_run_time = 0; } // DNS timeout is around 10s
|
||||
|
||||
if (ntp_time > START_VALID_TIME) {
|
||||
Rtc.utc_time = ntp_time;
|
||||
Rtc.nanos = ntp_nanos % 1000000000;
|
||||
ntp_sync_minute = 60; // Sync so block further requests
|
||||
RtcSync("NTP");
|
||||
} else {
|
||||
|
|
@ -893,7 +895,7 @@ void WifiPollNtp() {
|
|||
}
|
||||
}
|
||||
|
||||
uint32_t WifiGetNtp(void) {
|
||||
uint64_t WifiGetNtp(void) {
|
||||
static uint8_t ntp_server_id = 0;
|
||||
|
||||
// AddLog(LOG_LEVEL_DEBUG, PSTR("NTP: Start NTP Sync %d ..."), ntp_server_id);
|
||||
|
|
@ -983,7 +985,12 @@ uint32_t WifiGetNtp(void) {
|
|||
ntp_server_id++; // Next server next time
|
||||
return 0;
|
||||
}
|
||||
return secs_since_1900 - 2208988800UL;
|
||||
uint32_t tmp_fraction = (uint32_t)packet_buffer[44] << 24;
|
||||
tmp_fraction |= (uint32_t)packet_buffer[45] << 16;
|
||||
tmp_fraction |= (uint32_t)packet_buffer[46] << 8;
|
||||
tmp_fraction |= (uint32_t)packet_buffer[47];
|
||||
uint32_t fraction = (((uint64_t)tmp_fraction) * 1000000000) >> 32;
|
||||
return (((uint64_t)secs_since_1900) - 2208988800UL) * 1000000000 + fraction;
|
||||
}
|
||||
delay(10);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -491,7 +491,7 @@ void KNX_INIT(void)
|
|||
device_param[KNX_HUMIDITY-1].show = true;
|
||||
}
|
||||
#ifdef USE_DS18x20
|
||||
if (PinUsed(GPIO_DSB)) {
|
||||
if (PinUsed(GPIO_DSB, GPIO_ANY)) {
|
||||
device_param[KNX_TEMPERATURE-1].show = true;
|
||||
}
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -36,6 +36,7 @@ extern "C" {
|
|||
4, /* number of elements */
|
||||
nullptr,
|
||||
(const be_ctypes_structure_item_t[4]) {
|
||||
// Warning: fields below need to be in alphabetical order
|
||||
{ "devices_present", offsetof(TasmotaGlobal_t, devices_present), 0, 0, ctypes_u8, 0 },
|
||||
{ "fast_loop_enabled", offsetof(TasmotaGlobal_t, berry_fast_loop_enabled), 0, 0, ctypes_u8, 0 },
|
||||
{ "restart_flag", offsetof(TasmotaGlobal_t, restart_flag), 0, 0, ctypes_u8, 0 },
|
||||
|
|
@ -47,10 +48,11 @@ extern "C" {
|
|||
2, /* number of elements */
|
||||
nullptr,
|
||||
(const be_ctypes_structure_item_t[2]) {
|
||||
// Warning: fields below need to be in alphabetical order
|
||||
{ "bootcount", offsetof(TSettings, bootcount), 0, 0, ctypes_u16, 0 },
|
||||
{ "sleep", offsetof(TSettings, sleep), 0, 0, ctypes_u8, 0 },
|
||||
}};
|
||||
|
||||
}
|
||||
|
||||
#endif // USE_BERRY
|
||||
#endif // USE_BERRY
|
||||
|
|
|
|||
|
|
@ -987,9 +987,12 @@ bool CmndTM1637Clock(void)
|
|||
\*********************************************************************************************/
|
||||
void TM1637ShowTime()
|
||||
{
|
||||
uint8_t hr = RtcTime.hour;
|
||||
uint8_t mn = RtcTime.minute;
|
||||
uint8_t sc = RtcTime.second;
|
||||
struct TIME_T t = RtcTime;
|
||||
BreakNanoTime(Rtc.local_time, Rtc.nanos + (millis() - Rtc.millis) * 1000000, t);
|
||||
uint8_t hr = t.hour;
|
||||
uint8_t mn = t.minute;
|
||||
uint8_t sc = t.second;
|
||||
uint16_t ms = t.nanos / 1000000;
|
||||
|
||||
if (!TM1637Data.clock_24)
|
||||
{
|
||||
|
|
@ -1009,12 +1012,14 @@ void TM1637ShowTime()
|
|||
|
||||
if (TM1637 == TM1637Data.display_type)
|
||||
{
|
||||
uint8_t colon = ms > 500? 0: 128;
|
||||
uint8_t rawBytes[1];
|
||||
for (uint32_t i = 0; i < 4; i++)
|
||||
uint8_t width = Settings->display_width >= 6? 6: 4;
|
||||
for (uint32_t i = 0; i < width; i++)
|
||||
{
|
||||
rawBytes[0] = tm1637display->encode(tm[i]);
|
||||
if ((millis() % 1000) > 500 && (i == 1))
|
||||
rawBytes[0] = rawBytes[0] | 128;
|
||||
if (i == 1 || (i == 3 && width > 4))
|
||||
rawBytes[0] = rawBytes[0] | colon;
|
||||
tm1637display->printRaw(rawBytes, 1, TM1637Data.digit_order[i]);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,6 +114,7 @@ bool Bp5758dSetChannels(void) {
|
|||
if (cur_col_10[0]==0 && cur_col_10[1]==0 && cur_col_10[2]==0 && cur_col_10[3]==0 && cur_col_10[4]==0) {
|
||||
Bp5758dStart(BP5758D_ADDR_SETUP);
|
||||
Bp5758dWrite(BP5758D_DISABLE_OUTPUTS_ALL);
|
||||
Bp5758dStop();
|
||||
Bp5758dStart(BP5758D_ADDR_SLEEP);
|
||||
Bp5758dStop();
|
||||
bIsSleeping = true;
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
xsns_05_ds18x20.ino - DS18x20 temperature sensor support for Tasmota
|
||||
|
||||
Copyright (C) 2021 Theo Arends
|
||||
Copyright (C) 2021 Theo Arends and md5sum-as (https://github.com/md5sum-as)
|
||||
|
||||
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
|
||||
|
|
@ -26,11 +26,11 @@
|
|||
#define XSNS_05 5
|
||||
|
||||
//#define USE_DS18x20_RECONFIGURE // When sensor is lost keep retrying or re-configure
|
||||
//#define DS18x20_USE_ID_AS_NAME // Use last 3 bytes for naming of sensors
|
||||
|
||||
//#define DS18x20_USE_ID_AS_NAME // Use last 3 bytes for naming of sensors
|
||||
|
||||
/* #define DS18x20_USE_ID_ALIAS in my_user_config.h or user_config_override.h
|
||||
* Use alias for fixed sensor name in scripts by autoexec. Command: DS18Alias XXXXXXXXXXXXXXXX,N where XXXXXXXXXXXXXXXX full serial and N number 1-255
|
||||
* Result in JSON: "DS18Alias_2":{"Id":"000003287CD8","Temperature":26.3} (example with N=2)
|
||||
* Result in JSON: "DS18Sens_2":{"Id":"000003287CD8","Temperature":26.3} (example with N=2)
|
||||
* add 8 bytes used memory
|
||||
*/
|
||||
|
||||
|
|
@ -45,7 +45,7 @@
|
|||
#define W1_WRITE_SCRATCHPAD 0x4E
|
||||
#define W1_READ_SCRATCHPAD 0xBE
|
||||
|
||||
#ifndef DS18X20_MAX_SENSORS // DS18X20_MAX_SENSORS fallback to 8 if not defined in user_config_override.h
|
||||
#ifndef DS18X20_MAX_SENSORS // DS18X20_MAX_SENSORS fallback to 8 if not defined in user_config_override.h
|
||||
#define DS18X20_MAX_SENSORS 8
|
||||
#endif
|
||||
|
||||
|
|
@ -60,18 +60,26 @@ struct {
|
|||
uint8_t address[8];
|
||||
uint8_t index;
|
||||
uint8_t valid;
|
||||
int8_t pins_id;
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
uint8_t alias;
|
||||
#endif //DS18x20_USE_ID_ALIAS
|
||||
#endif // DS18x20_USE_ID_ALIAS
|
||||
} ds18x20_sensor[DS18X20_MAX_SENSORS];
|
||||
|
||||
struct {
|
||||
int8_t pin = 0; // Shelly GPIO3 input only
|
||||
int8_t pin_out = 0; // Shelly GPIO00 output only
|
||||
bool dual_mode = false; // Single pin mode
|
||||
} ds18x20_gpios[MAX_DSB];
|
||||
|
||||
struct {
|
||||
#ifdef W1_PARASITE_POWER
|
||||
uint32_t w1_power_until = 0;
|
||||
uint8_t current_sensor = 0;
|
||||
#endif
|
||||
char name[17];
|
||||
uint8_t sensors = 0;
|
||||
uint8_t sensors;
|
||||
uint8_t gpios; // Count of GPIO found
|
||||
uint8_t input_mode = 0; // INPUT or INPUT_PULLUP (=2)
|
||||
int8_t pin = 0; // Shelly GPIO3 input only
|
||||
int8_t pin_out = 0; // Shelly GPIO00 output only
|
||||
|
|
@ -301,45 +309,62 @@ bool OneWireCrc8(uint8_t *addr) {
|
|||
/********************************************************************************************/
|
||||
|
||||
void Ds18x20Init(void) {
|
||||
DS18X20Data.pin = Pin(GPIO_DSB);
|
||||
DS18X20Data.input_mode = Settings->flag3.ds18x20_internal_pullup ? INPUT_PULLUP : INPUT; // SetOption74 - Enable internal pullup for single DS18x20 sensor
|
||||
DS18X20Data.gpios = 0;
|
||||
for (uint32_t pins = 0; pins < MAX_DSB; pins++) {
|
||||
if (PinUsed(GPIO_DSB, pins)) {
|
||||
ds18x20_gpios[pins].pin = Pin(GPIO_DSB, pins);
|
||||
|
||||
if (PinUsed(GPIO_DSB_OUT)) {
|
||||
DS18X20Data.pin_out = Pin(GPIO_DSB_OUT);
|
||||
DS18X20Data.dual_mode = true; // Dual pins mode as used by Shelly
|
||||
pinMode(DS18X20Data.pin_out, OUTPUT);
|
||||
pinMode(DS18X20Data.pin, DS18X20Data.input_mode);
|
||||
}
|
||||
|
||||
onewire_last_discrepancy = 0;
|
||||
onewire_last_device_flag = false;
|
||||
onewire_last_family_discrepancy = 0;
|
||||
for (uint32_t i = 0; i < 8; i++) {
|
||||
onewire_rom_id[i] = 0;
|
||||
if (PinUsed(GPIO_DSB_OUT, pins)) {
|
||||
ds18x20_gpios[pins].dual_mode = true;
|
||||
ds18x20_gpios[pins].pin_out = Pin(GPIO_DSB_OUT, pins);
|
||||
}
|
||||
DS18X20Data.gpios++;
|
||||
}
|
||||
}
|
||||
|
||||
uint64_t ids[DS18X20_MAX_SENSORS];
|
||||
DS18X20Data.sensors = 0;
|
||||
while (DS18X20Data.sensors < DS18X20_MAX_SENSORS) {
|
||||
if (!OneWireSearch(ds18x20_sensor[DS18X20Data.sensors].address)) {
|
||||
break;
|
||||
DS18X20Data.input_mode = Settings->flag3.ds18x20_internal_pullup ? INPUT_PULLUP : INPUT; // SetOption74 - Enable internal pullup for single DS18x20 sensor
|
||||
|
||||
for (uint32_t pins = 0; pins < DS18X20Data.gpios; pins++) {
|
||||
DS18X20Data.pin = ds18x20_gpios[pins].pin;
|
||||
DS18X20Data.dual_mode = ds18x20_gpios[pins].dual_mode;
|
||||
if (ds18x20_gpios[pins].dual_mode) {
|
||||
DS18X20Data.pin_out = ds18x20_gpios[pins].pin_out;
|
||||
pinMode(DS18X20Data.pin_out, OUTPUT);
|
||||
pinMode(DS18X20Data.pin, DS18X20Data.input_mode);
|
||||
}
|
||||
if (OneWireCrc8(ds18x20_sensor[DS18X20Data.sensors].address) &&
|
||||
((ds18x20_sensor[DS18X20Data.sensors].address[0] == DS18S20_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == DS1822_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == DS18B20_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == MAX31850_CHIPID))) {
|
||||
ds18x20_sensor[DS18X20Data.sensors].index = DS18X20Data.sensors;
|
||||
ids[DS18X20Data.sensors] = ds18x20_sensor[DS18X20Data.sensors].address[0]; // Chip id
|
||||
for (uint32_t j = 6; j > 0; j--) {
|
||||
ids[DS18X20Data.sensors] = ids[DS18X20Data.sensors] << 8 | ds18x20_sensor[DS18X20Data.sensors].address[j];
|
||||
|
||||
onewire_last_discrepancy = 0;
|
||||
onewire_last_device_flag = false;
|
||||
onewire_last_family_discrepancy = 0;
|
||||
for (uint32_t i = 0; i < 8; i++) {
|
||||
onewire_rom_id[i] = 0;
|
||||
}
|
||||
|
||||
while (DS18X20Data.sensors < DS18X20_MAX_SENSORS) {
|
||||
if (!OneWireSearch(ds18x20_sensor[DS18X20Data.sensors].address)) {
|
||||
break;
|
||||
}
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
ds18x20_sensor[DS18X20Data.sensors].alias=0;
|
||||
if (OneWireCrc8(ds18x20_sensor[DS18X20Data.sensors].address) &&
|
||||
((ds18x20_sensor[DS18X20Data.sensors].address[0] == DS18S20_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == DS1822_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == DS18B20_CHIPID) ||
|
||||
(ds18x20_sensor[DS18X20Data.sensors].address[0] == MAX31850_CHIPID))) {
|
||||
ds18x20_sensor[DS18X20Data.sensors].index = DS18X20Data.sensors;
|
||||
ids[DS18X20Data.sensors] = ds18x20_sensor[DS18X20Data.sensors].address[0]; // Chip id
|
||||
for (uint32_t j = 6; j > 0; j--) {
|
||||
ids[DS18X20Data.sensors] = ids[DS18X20Data.sensors] << 8 | ds18x20_sensor[DS18X20Data.sensors].address[j];
|
||||
}
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
ds18x20_sensor[DS18X20Data.sensors].alias=0;
|
||||
#endif
|
||||
DS18X20Data.sensors++;
|
||||
ds18x20_sensor[DS18X20Data.sensors].pins_id = pins;
|
||||
DS18X20Data.sensors++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < DS18X20Data.sensors; i++) {
|
||||
for (uint32_t j = i + 1; j < DS18X20Data.sensors; j++) {
|
||||
if (ids[ds18x20_sensor[i].index] > ids[ds18x20_sensor[j].index]) { // Sort ascending
|
||||
|
|
@ -347,21 +372,27 @@ void Ds18x20Init(void) {
|
|||
}
|
||||
}
|
||||
}
|
||||
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_DSB D_SENSORS_FOUND " %d"), DS18X20Data.sensors);
|
||||
}
|
||||
|
||||
void Ds18x20Convert(void) {
|
||||
OneWireReset();
|
||||
for (uint8_t i = 0; i < DS18X20Data.gpios; i++) {
|
||||
DS18X20Data.pin = ds18x20_gpios[i].pin;
|
||||
DS18X20Data.dual_mode = ds18x20_gpios[i].dual_mode;
|
||||
DS18X20Data.pin_out = ds18x20_gpios[i].pin_out;
|
||||
OneWireReset();
|
||||
#ifdef W1_PARASITE_POWER
|
||||
// With parasite power address one sensor at a time
|
||||
if (++DS18X20Data.current_sensor >= DS18X20Data.sensors)
|
||||
DS18X20Data.current_sensor = 0;
|
||||
OneWireSelect(ds18x20_sensor[DS18X20Data.current_sensor].address);
|
||||
// With parasite power address one sensor at a time
|
||||
if (++DS18X20Data.current_sensor >= DS18X20Data.sensors)
|
||||
DS18X20Data.current_sensor = 0;
|
||||
OneWireSelect(ds18x20_sensor[DS18X20Data.current_sensor].address);
|
||||
#else
|
||||
OneWireWrite(W1_SKIP_ROM); // Address all Sensors on Bus
|
||||
OneWireWrite(W1_SKIP_ROM); // Address all Sensors on Bus
|
||||
#endif
|
||||
OneWireWrite(W1_CONVERT_TEMP); // start conversion, no parasite power on at the end
|
||||
// delay(750); // 750ms should be enough for 12bit conv
|
||||
OneWireWrite(W1_CONVERT_TEMP); // start conversion, no parasite power on at the end
|
||||
// delay(750); // 750ms should be enough for 12bit conv
|
||||
}
|
||||
}
|
||||
|
||||
bool Ds18x20Read(uint8_t sensor) {
|
||||
|
|
@ -370,6 +401,9 @@ bool Ds18x20Read(uint8_t sensor) {
|
|||
int8_t sign = 1;
|
||||
|
||||
uint8_t index = ds18x20_sensor[sensor].index;
|
||||
DS18X20Data.pin = ds18x20_gpios[ds18x20_sensor[index].pins_id].pin;
|
||||
DS18X20Data.pin_out = ds18x20_gpios[ds18x20_sensor[index].pins_id].pin_out;
|
||||
DS18X20Data.dual_mode = ds18x20_gpios[ds18x20_sensor[index].pins_id].dual_mode;
|
||||
if (ds18x20_sensor[index].valid) { ds18x20_sensor[index].valid--; }
|
||||
for (uint32_t retry = 0; retry < 3; retry++) {
|
||||
OneWireReset();
|
||||
|
|
@ -446,15 +480,14 @@ void Ds18x20Name(uint8_t sensor) {
|
|||
}
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%s"), DS18X20Data.name, IndexSeparator(), address);
|
||||
#else
|
||||
uint8_t print_ind = sensor +1;
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
if (ds18x20_sensor[sensor].alias) {
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("DS18Alias%c%d"), IndexSeparator(), ds18x20_sensor[sensor].alias);
|
||||
} else {
|
||||
#endif
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%d"), DS18X20Data.name, IndexSeparator(), sensor +1);
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("DS18Sens"));
|
||||
print_ind = ds18x20_sensor[sensor].alias;
|
||||
}
|
||||
#endif
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%d"), DS18X20Data.name, IndexSeparator(), print_ind);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -545,7 +578,7 @@ void CmndDSAlias(void) {
|
|||
uint8_t sensor=255;
|
||||
char argument[XdrvMailbox.data_len];
|
||||
char address[17];
|
||||
|
||||
|
||||
if (ArgC()==2) {
|
||||
tmp=atoi(ArgV(argument, 2));
|
||||
ArgV(argument,1);
|
||||
|
|
@ -581,7 +614,7 @@ void CmndDSAlias(void) {
|
|||
bool Xsns05(uint8_t function) {
|
||||
bool result = false;
|
||||
|
||||
if (PinUsed(GPIO_DSB)) {
|
||||
if (PinUsed(GPIO_DSB, GPIO_ANY)) {
|
||||
switch (function) {
|
||||
case FUNC_INIT:
|
||||
Ds18x20Init();
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
/*
|
||||
xsns_05_esp32_ds18x20.ino - DS18x20 temperature sensor support for ESP32 Tasmota
|
||||
|
||||
Copyright (C) 2021 Heiko Krupp and Theo Arends
|
||||
Copyright (C) 2021 Heiko Krupp, Theo Arends and md5sum-as (https://github.com/md5sum-as)
|
||||
|
||||
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
|
||||
|
|
@ -17,7 +17,6 @@
|
|||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
|
||||
#ifdef ESP32
|
||||
#ifdef USE_DS18x20
|
||||
/*********************************************************************************************\
|
||||
|
|
@ -26,7 +25,7 @@
|
|||
|
||||
#define XSNS_05 5
|
||||
|
||||
//#define DS18x20_USE_ID_AS_NAME // Use last 3 bytes for naming of sensors
|
||||
//#define DS18x20_USE_ID_AS_NAME // Use last 3 bytes for naming of sensors
|
||||
|
||||
/* #define DS18x20_USE_ID_ALIAS in my_user_config.h or user_config_override.h
|
||||
* Use alias for fixed sensor name in scripts by autoexec. Command: DS18Alias XXXXXXXXXXXXXXXX,N where XXXXXXXXXXXXXXXX full serial and N number 1-255
|
||||
|
|
@ -43,7 +42,7 @@
|
|||
#define W1_CONVERT_TEMP 0x44
|
||||
#define W1_READ_SCRATCHPAD 0xBE
|
||||
|
||||
#ifndef DS18X20_MAX_SENSORS // DS18X20_MAX_SENSORS fallback to 8 if not defined in user_config_override.h
|
||||
#ifndef DS18X20_MAX_SENSORS // DS18X20_MAX_SENSORS fallback to 8 if not defined in user_config_override.h
|
||||
#define DS18X20_MAX_SENSORS 8
|
||||
#endif
|
||||
|
||||
|
|
@ -57,51 +56,63 @@ struct {
|
|||
uint8_t address[8];
|
||||
uint8_t index;
|
||||
uint8_t valid;
|
||||
int8_t pins_id;
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
uint8_t alias;
|
||||
#endif //DS18x20_USE_ID_ALIAS
|
||||
#endif //DS18x20_USE_ID_ALIAS
|
||||
} ds18x20_sensor[DS18X20_MAX_SENSORS];
|
||||
|
||||
#include <OneWire.h>
|
||||
OneWire *ds = nullptr;
|
||||
OneWire *ds18x20_gpios[MAX_DSB];
|
||||
|
||||
struct {
|
||||
char name[17];
|
||||
uint8_t sensors = 0;
|
||||
uint8_t sensors;
|
||||
uint8_t gpios; // Count of GPIO found
|
||||
} DS18X20Data;
|
||||
|
||||
/********************************************************************************************/
|
||||
|
||||
#include <OneWire.h>
|
||||
|
||||
OneWire *ds = nullptr;
|
||||
|
||||
void Ds18x20Init(void) {
|
||||
ds = new OneWire(Pin(GPIO_DSB));
|
||||
|
||||
DS18X20Data.gpios = 0;
|
||||
for (uint32_t pins = 0; pins < MAX_DSB; pins++) {
|
||||
if (PinUsed(GPIO_DSB, pins)) {
|
||||
ds18x20_gpios[pins] = new OneWire(Pin(GPIO_DSB, pins));
|
||||
DS18X20Data.gpios++;
|
||||
}
|
||||
}
|
||||
Ds18x20Search();
|
||||
AddLog(LOG_LEVEL_DEBUG, PSTR(D_LOG_DSB D_SENSORS_FOUND " %d"), DS18X20Data.sensors);
|
||||
}
|
||||
|
||||
void Ds18x20Search(void) {
|
||||
uint8_t num_sensors=0;
|
||||
uint8_t num_sensors = 0;
|
||||
uint8_t sensor = 0;
|
||||
|
||||
ds->reset_search();
|
||||
for (num_sensors = 0; num_sensors < DS18X20_MAX_SENSORS; num_sensors) {
|
||||
if (!ds->search(ds18x20_sensor[num_sensors].address)) {
|
||||
ds->reset_search();
|
||||
break;
|
||||
}
|
||||
// If CRC Ok and Type DS18S20, DS1822, DS18B20 or MAX31850
|
||||
if ((OneWire::crc8(ds18x20_sensor[num_sensors].address, 7) == ds18x20_sensor[num_sensors].address[7]) &&
|
||||
((ds18x20_sensor[num_sensors].address[0] == DS18S20_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == DS1822_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == DS18B20_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == MAX31850_CHIPID))) {
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
ds18x20_sensor[num_sensors].alias=0;
|
||||
for (uint8_t pins = 0; pins < DS18X20Data.gpios; pins++) {
|
||||
ds = ds18x20_gpios[pins];
|
||||
ds->reset_search();
|
||||
for (num_sensors; num_sensors < DS18X20_MAX_SENSORS; num_sensors) {
|
||||
if (!ds->search(ds18x20_sensor[num_sensors].address)) {
|
||||
ds->reset_search();
|
||||
break;
|
||||
}
|
||||
// If CRC Ok and Type DS18S20, DS1822, DS18B20 or MAX31850
|
||||
if ((OneWire::crc8(ds18x20_sensor[num_sensors].address, 7) == ds18x20_sensor[num_sensors].address[7]) &&
|
||||
((ds18x20_sensor[num_sensors].address[0] == DS18S20_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == DS1822_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == DS18B20_CHIPID) ||
|
||||
(ds18x20_sensor[num_sensors].address[0] == MAX31850_CHIPID))) {
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
ds18x20_sensor[num_sensors].alias=0;
|
||||
#endif
|
||||
num_sensors++;
|
||||
ds18x20_sensor[num_sensors].pins_id = pins;
|
||||
num_sensors++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (uint32_t i = 0; i < num_sensors; i++) {
|
||||
ds18x20_sensor[i].index = i;
|
||||
}
|
||||
|
|
@ -116,10 +127,13 @@ void Ds18x20Search(void) {
|
|||
}
|
||||
|
||||
void Ds18x20Convert(void) {
|
||||
ds->reset();
|
||||
ds->write(W1_SKIP_ROM); // Address all Sensors on Bus
|
||||
ds->write(W1_CONVERT_TEMP); // start conversion, no parasite power on at the end
|
||||
// delay(750); // 750ms should be enough for 12bit conv
|
||||
for (uint32_t i = 0; i < DS18X20Data.gpios; i++) {
|
||||
ds = ds18x20_gpios[i];
|
||||
ds->reset();
|
||||
ds->write(W1_SKIP_ROM); // Address all Sensors on Bus
|
||||
ds->write(W1_CONVERT_TEMP); // start conversion, no parasite power on at the end
|
||||
// delay(750); // 750ms should be enough for 12bit conv
|
||||
}
|
||||
}
|
||||
|
||||
bool Ds18x20Read(uint8_t sensor, float &t) {
|
||||
|
|
@ -130,7 +144,7 @@ bool Ds18x20Read(uint8_t sensor, float &t) {
|
|||
|
||||
uint8_t index = ds18x20_sensor[sensor].index;
|
||||
if (ds18x20_sensor[index].valid) { ds18x20_sensor[index].valid--; }
|
||||
|
||||
ds = ds18x20_gpios[ds18x20_sensor[index].pins_id];
|
||||
ds->reset();
|
||||
ds->select(ds18x20_sensor[index].address);
|
||||
ds->write(W1_READ_SCRATCHPAD); // Read Scratchpad
|
||||
|
|
@ -185,15 +199,14 @@ void Ds18x20Name(uint8_t sensor) {
|
|||
}
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%s"), DS18X20Data.name, IndexSeparator(), address);
|
||||
#else
|
||||
uint8_t print_ind = sensor +1;
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
if (ds18x20_sensor[sensor].alias) {
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("DS18Alias%c%d"), IndexSeparator(), ds18x20_sensor[sensor].alias);
|
||||
} else {
|
||||
#endif
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%d"), DS18X20Data.name, IndexSeparator(), sensor +1);
|
||||
#ifdef DS18x20_USE_ID_ALIAS
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("DS18Sens"));
|
||||
print_ind = ds18x20_sensor[sensor].alias;
|
||||
}
|
||||
#endif
|
||||
snprintf_P(DS18X20Data.name, sizeof(DS18X20Data.name), PSTR("%s%c%d"), DS18X20Data.name, IndexSeparator(), print_ind);
|
||||
#endif
|
||||
}
|
||||
}
|
||||
|
|
@ -279,7 +292,7 @@ void CmndDSAlias(void) {
|
|||
uint8_t sensor=255;
|
||||
char argument[XdrvMailbox.data_len];
|
||||
char address[17];
|
||||
|
||||
|
||||
if (ArgC()==2) {
|
||||
tmp=atoi(ArgV(argument, 2));
|
||||
ArgV(argument,1);
|
||||
|
|
@ -315,7 +328,7 @@ void CmndDSAlias(void) {
|
|||
bool Xsns05(uint8_t function) {
|
||||
bool result = false;
|
||||
|
||||
if (PinUsed(GPIO_DSB)) {
|
||||
if (PinUsed(GPIO_DSB, GPIO_ANY)) {
|
||||
switch (function) {
|
||||
case FUNC_INIT:
|
||||
Ds18x20Init();
|
||||
|
|
|
|||
Loading…
Reference in New Issue