Read this before creating new topic:
- Search forum for similar topics
- Check https://docs.blynk.io
- Add details :
• Hardware model + communication type. For example: ESP32
• Smartphone OS (iOS or Android) + OS version
• Blynk server region
• Blynk Library version
• Post your FORMATTED sketch code. Remove your AUTH TOKEN from code. Don’t post screenshots
• Post your serial monitor output when experiencing some issues
My code is designed to:
- Allow WiFi provisioning through Bluetooth
- Control a fan based on a cycle (5 seconds on, 29 minutes 55 seconds off).
- Detect motion using an RCWL-0516 microwave sensor.
- Capture an image using the ESP32 camera and send it to the Blynk app.
- Provide a virtual button in the Blynk app to manually control the fan.
cpp
#define BLYNK_TEMPLATE_ID "YourTemplateID" // Replace with your actual template ID
#define BLYNK_TEMPLATE_NAME "YourTemplateName" // Replace with your actual template name
#define BLYNK_AUTH_TOKEN "YourBlynkAuthToken" // Replace with your actual Blynk Auth Token
#include <WiFi.h>
#include <BlynkSimpleEsp32_BLE.h>
#include <BLEDevice.h>
#include <BLEUtils.h>
#include <BLEServer.h>
#include "esp_camera.h" // Include the correct header
// Camera Configuration (Using camera_config_t)
camera_config_t config;
// Fan Control Pin
#define FAN_PIN 5 // Adjust based on your wiring
#define SENSOR_PIN 14 // Pin for RCWL-0516 sensor
RCWL_0516 sensor(SENSOR_PIN); // Microwave sensor object
int fanState = LOW;
unsigned long previousMillis = 0;
unsigned long interval = 300000; // 5 seconds on + 29 minutes 55 seconds off
unsigned long fanDuration = 5000; // Fan run for 5 seconds
// Blynk Timer
BlynkTimer timer;
void setup() {
Serial.begin(115200);
// Camera Configuration
config.pin_pwdn = 32;
config.pin_reset = -1;
config.pin_xclk = 0;
config.pin_sccb_sda = 26;
config.pin_sccb_scl = 27;
config.pin_d7 = 35;
config.pin_d6 = 34;
config.pin_d5 = 39;
config.pin_d4 = 36;
config.pin_d3 = 21;
config.pin_d2 = 19;
config.pin_d1 = 18;
config.pin_d0 = 5;
config.pin_vsync = 25;
config.pin_href = 23;
config.pin_pclk = 22;
config.xclk_freq_hz = 20000000;
config.ledc_timer = LEDC_TIMER_0;
config.ledc_channel = LEDC_CHANNEL_0;
config.pixel_format = PIXFORMAT_JPEG;
config.frame_size = FRAMESIZE_UXGA;
config.jpeg_quality = 12;
config.fb_count = 2;
// Initialize Camera
if (!esp_camera_init(&config)) {
Serial.println("Camera initialization failed!");
return;
}
// Start Blynk with BLE (Bluetooth provisioning)
Blynk.begin(BLYNK_AUTH_TOKEN, BLYNK_TEMPLATE_ID, BLYNK_TEMPLATE_NAME, BLE);
// Initialize Fan Pin
pinMode(FAN_PIN, OUTPUT);
digitalWrite(FAN_PIN, LOW); // Ensure fan is off initially
// Initialize the sensor
sensor.begin();
// Set up a timer for cycling the fan
timer.setInterval(5000L, fanCycle); // Fan cycle interval
// Set up a timer to check for movement
timer.setInterval(100, checkMovement); // Movement check every 100ms
}
void loop() {
// Run Blynk and handle BLE provisioning
Blynk.run();
timer.run(); // Run Blynk Timer
if (sensor.isDetected()) {
Serial.println("Motion Detected!");
takePictureAndSend();
}
}
// Fan control logic
void fanCycle() {
unsigned long currentMillis = millis();
if (fanState == HIGH && currentMillis - previousMillis >= fanDuration) {
// Turn off the fan after 5 seconds
digitalWrite(FAN_PIN, LOW);
fanState = LOW;
previousMillis = currentMillis;
interval = 1790000; // Set interval to 29 minutes 55 seconds
}
else if (fanState == LOW && currentMillis - previousMillis >= interval) {
// Turn on the fan after 29 minutes 55 seconds
digitalWrite(FAN_PIN, HIGH);
fanState = HIGH;
previousMillis = currentMillis;
interval = 1790000; // Reset the interval to 29 minutes 55 seconds
}
}
// Capture image from camera and send via Blynk
void takePictureAndSend() {
// Capture the image from the camera
camera_fb_t *fb = esp_camera_fb_get();
if (!fb) {
Serial.println("Camera capture failed");
return;
}
// Send the picture to Blynk
Blynk.virtualWrite(V1, fb->buf, fb->len);
// Send a notification to Blynk app
Blynk.notify("Motion Detected! Check the image.");
// Free the memory used by the frame buffer
esp_camera_fb_return(fb);
}
// Blynk virtual button to control fan
BLYNK_WRITE(V0) {
if (param.asInt() == 1) {
digitalWrite(FAN_PIN, HIGH); // Turn on fan
fanState = HIGH;
} else {
digitalWrite(FAN_PIN, LOW); // Turn off fan
fanState = LOW;
}
}
// Movement check function
void checkMovement() {
if (sensor.isDetected()) {
Serial.println("Movement detected!");
takePictureAndSend();
}
}
My serial monitor shows a ridiculously long error message. I have to post it in a separate post:
Serial Monitor:
[Unformatted compiler error messages removed by moderator]
[Unformatted compiler error messages removed by moderator]
@drehawk please edit your posts and add triple backticks at the beginning and end of your compiler error messages in post 2 and 3.
The final message…
presumably refers to a camera configuration that should exist in this file…
but you haven’t provided any of the .h files that you’re using in your post.
Pete.
Thank you. I used ChatGPT for the code, and it did not include “h” files. I will get that figured out then try to upload it again. Hopefully, that will fix everything.
As you ignored my request to correctly format your compiler error messages with triple backticks, these messages have been removed.
Pete.
Pete, I appreciate your attention. I am trying to fix my errors before I resubmit. Your time and insights are invaluable. I do not want to waste it. I want to see what I can do to fix the issues that you pointed out before I re-post.
* @file BlynkSimpleEsp32_BLE.h
* @author Volodymyr Shymanskyy
* @license This project is released under the MIT License (MIT)
* @copyright Copyright (c) 2015 Volodymyr Shymanskyy
* @date Nov 2017
* @brief
*
*/
#ifndef BlynkSimpleEsp32_BLE_h
#define BlynkSimpleEsp32_BLE_h
#ifndef BLYNK_INFO_CONNECTION
#define BLYNK_INFO_CONNECTION "Esp32_BLE"
#endif
#define BLYNK_SEND_ATOMIC
#define BLYNK_SEND_CHUNK 20
//#define BLYNK_SEND_THROTTLE 20
#include <BlynkApiArduino.h>
#include <Blynk/BlynkProtocol.h>
#include <utility/BlynkFifo.h>
#include <BLEDevice.h>
#include <BLEServer.h>
#include <BLEUtils.h>
#include <BLE2902.h>
#define SERVICE_UUID "713D0000-503E-4C75-BA94-3148F18D941E"
#define CHARACTERISTIC_UUID_RX "713D0003-503E-4C75-BA94-3148F18D941E"
#define CHARACTERISTIC_UUID_TX "713D0002-503E-4C75-BA94-3148F18D941E"
class BlynkTransportEsp32_BLE :
public BLEServerCallbacks,
public BLECharacteristicCallbacks
{
public:
BlynkTransportEsp32_BLE()
: mConn (false)
, mName ("Blynk")
{}
void setDeviceName(const char* name) {
mName = name;
}
// IP redirect not available
void begin(char BLYNK_UNUSED *h, uint16_t BLYNK_UNUSED p) {}
void begin() {
// Create the BLE Device
BLEDevice::init(mName);
// Create the BLE Server
pServer = BLEDevice::createServer();
pServer->setCallbacks(this);
// Create the BLE Service
pService = pServer->createService(SERVICE_UUID);
// Create a BLE Characteristic
pCharacteristicTX = pService->createCharacteristic(
CHARACTERISTIC_UUID_TX,
BLECharacteristic::PROPERTY_NOTIFY
);
pCharacteristicTX->addDescriptor(new BLE2902());
pCharacteristicRX = pService->createCharacteristic(
CHARACTERISTIC_UUID_RX,
BLECharacteristic::PROPERTY_WRITE
);
pCharacteristicRX->setCallbacks(this);
// Start the service
pService->start();
// Start advertising
pServer->getAdvertising()->addServiceUUID(pService->getUUID());
pServer->getAdvertising()->start();
}
bool connect() {
mBuffRX.clear();
return mConn = true;
}
void disconnect() {
mConn = false;
}
bool connected() {
return mConn;
}
size_t read(void* buf, size_t len) {
millis_time_t start = BlynkMillis();
while (BlynkMillis() - start < BLYNK_TIMEOUT_MS) {
if (available() < len) {
delay(1);
} else {
break;
}
}
size_t res = mBuffRX.get((uint8_t*)buf, len);
return res;
}
size_t write(const void* buf, size_t len) {
pCharacteristicTX->setValue((uint8_t*)buf, len);
pCharacteristicTX->notify();
return len;
}
size_t available() {
size_t rxSize = mBuffRX.size();
return rxSize;
}
private:
void onConnect(BLEServer* pServer);
void onDisconnect(BLEServer* pServer);
void onWrite(BLECharacteristic *pCharacteristic) {
std::string rxValue = pCharacteristic->getValue();
if (rxValue.length() > 0) {
uint8_t* data = (uint8_t*)rxValue.data();
size_t len = rxValue.length();
BLYNK_DBG_DUMP(">> ", data, len);
mBuffRX.put(data, len);
}
}
private:
bool mConn;
const char* mName;
BLEServer *pServer;
BLEService *pService;
BLECharacteristic *pCharacteristicTX;
BLECharacteristic *pCharacteristicRX;
BlynkFifo<uint8_t, BLYNK_MAX_READBYTES*2> mBuffRX;
};
class BlynkEsp32_BLE
: public BlynkProtocol<BlynkTransportEsp32_BLE>
{
typedef BlynkProtocol<BlynkTransportEsp32_BLE> Base;
public:
BlynkEsp32_BLE(BlynkTransportEsp32_BLE& transp)
: Base(transp)
{}
void begin(const char* auth)
{
Base::begin(auth);
state = DISCONNECTED;
conn.begin();
}
void setDeviceName(const char* name) {
conn.setDeviceName(name);
}
};
#if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_BLYNK)
static BlynkTransportEsp32_BLE _blynkTransportBLE;
BlynkEsp32_BLE Blynk(_blynkTransportBLE);
#else
extern BlynkEsp32_BLE Blynk;
#endif
inline
void BlynkTransportEsp32_BLE::onConnect(BLEServer* pServer) {
BLYNK_LOG1(BLYNK_F("BLE connect"));
connect();
Blynk.startSession();
};
inline
void BlynkTransportEsp32_BLE::onDisconnect(BLEServer* pServer) {
BLYNK_LOG1(BLYNK_F("BLE disconnect"));
pServer->getAdvertising()->start();
Blynk.disconnect();
disconnect();
}
#include <BlynkWidgets.h>
#endif
I am starting to post the “h” files that were missing then I will try to upload again. If there is an error message at that point I will then post that error message.
You don’t need to post the library files that are added via #include < xxx.h>
The #include "esp_camera.h" line has the .h file name surrounded by quotation marks rather than <> meaning that it is a locally defined file, and will appear as a tab alongside your .ino file when you open your sketch in the IDE.
Your compiler was complaining that it couldn’t find info that it expected to find in this .h file.
Having said that, I doubt that you’ll be able to do Bluetooth provisioning using the Blynk legacy BLE libraries.
Pete.
I was trying to do Bluetooth with 2.0 libraries but appear to have chosen the wrong libraries.
Blynk Legacy used to support device to phone/tablet BT/BLE communication. Blynk IoT does not.
I suspect that the Blynk BT library you’ve included is left-over from Legacy days.
There are ways to do BT provisioning of WiFi credentials using non-Blynk libraries, but I’m not sure how you’re planning to handle provisioning of the Blynk auth token.
I suppose that if Blynk launches Matter support then a BT provisioning solution would be included.
Pete.