Polverine FAQ


Technical Details

Polverine is an advanced environmental sensing board designed for a wide range of applications, from IoT devices to industrial automation and smart home systems. This compact and versatile device combines cutting-edge sensor technology with powerful processing capabilities, making it an ideal solution for comprehensive environmental monitoring.

Key Components

Sensors

BMV080 - World's Smallest PM 2.5 Sensor
- Dimensions: 4.4 x 3.0 x 3.0 mm³ (sensing element)
- Measures PM2.5 mass concentration in real-time
- Fanless design for silent and maintenance-free operation
- Measurement range: 0 to 1000 μg/m³
- Output resolution: 1 μg/m³
- Can detect particles as small as 0.5 μm

BME690 - Integrated Environmental Sensor with A.I.
- Measures air quality index, temperature, humidity, and pressure
- Incorporates artificial intelligence for enhanced sensing capabilities

Microcontroller

ESP32-S3-Mini-1 from Espressif
- Dual-core 32-bit LX7 MCU running at 240MHz
- 2.4 GHz Wi-Fi and Bluetooth Low Energy connectivity
- 8 MB of Flash memory and 0.5 MB of PSRAM
- Advanced security features: AES, SHA, RSA, ECC, RNG, Secure Boot, Flash Encryption, Digital signature, HMAC module

 Board Features

Connectivity
- USB interface
- mikroBUS™ Connector
- Debug Connector (JTAG)
- Serial Connector
- Qwiic System Connector

Form Factor
- mikroBUS™ size: 25.4 x 28.6 mm

Power Supply Options
- USB interface (5V)
- mikroBUS™ 5V pin
- mikroBUS™ 3.3V pin
- 5V supplied to LDO that outputs 3.3V

Interfaces
- SPI: Used for BMV080 sensor communication
- I2C: Used for BME690 sensor communication
- UART: Available for external communication
- GPIO/PWM: Available for additional functionality
- Analog IN: For analog sensor inputs


How to install Expressif IDF and Flash my first binary application

  1. go to Expressif “Standard setup of toolchain for windows” Select "Windows Installer Download" and then select Universal Online Installer (first option in the list, see image below)
Polverine IDF Installer
Poverine IDF installer
  1. Run the installer using default settings. Grant all permissions when prompted. Do not execute fixes if the check shows all results are okay. This process may take some time as it installs the entire Python environment.
  2. Upon completion, the "ESP-IDF Command Prompt" and the "ESP-IDF PowerShell" will be activated. Add one of them your favorites (to add the Power Shell version right-click on the "ESP-IDF 5.3 PowerShell" icon from the Windows menu and select "Pin to Start" or "Pin to Taskbar").
  3. Place the desired .bin application in a folder on your computer. In this example we use "polverine_blink.bin"
  4. Connect Polverine to an USB port on your computer.
  5. Allow the USB drivers to install automatically.
  6. Open Device Manager and identify which port is being used. In this example, it's COM5.
  7. Using the IDF PowerShell, navigate to the directory where you placed the .bin file. In this example is W:/Polverine
  8. Execute the following single line command (change port and application names to suit your needs):
    esptool.py --chip esp32s3 --port COM5 --baud 460800 write_flash 0x10000 polverine_blink.bin
  1. If everything is OK, the device will start blinking. If it appears to be stuck, press the reset button.
  2. If you want to verify that the flash memory has been written correctly use the single line command:
    esptool.py verify_flash --diff yes 0x10000 polverine_mqtt_demo.bin
  3. Whenever you want to use the IDF tools, open the shortcut "ESP-IDF 5.3 PowerShell"

How to Install PlatformIO then compile & debug BLINK demo

  1. Open the web browser
  2. Navigate to Polverine GitHub repository
  3.  Click on the "CODE site" link to download Visual Studio Code
  4. Install Visual Studio Code
  5. Start Visual Studio Code
  6. Install PlatformIO from extensions manager
  7. Reload
  8. Select the Source Control Icon 
  9. Install GIT
  10. Reload Source Control
  11. Clone GitHub Polverine repository to local
  12. Using File Explorer copy the file polverine.json from boards folder in local git repo to C:\Users\username\.platformio\boards folder
  13. Open the folder with POLVERINE_BLINK demo source code from VSCode
  14. Wait (LONG) the VSCode/PlatformIO installs al tools and libraries.
  15.  Compile the POLVERINE_BLINK demo
  16. Connect a Polverine Board to local PC
  17. Upload the firmware to polverine board
  18. Download and Install the ZADIG tool
  19. Follow instructions to install libusbk on interface 2
  20. Debug the POLVERINE_BLINK demo

How to reinitialize Polverine

To restore an ESP32-S3 to its factory condition (virgin chip state), you need to perform a flash erase.

Execute the following command:

esptool.py --chip esp32s3 --port [YOUR_PORT] --baud 921600 erase_flash

To load the bootloader, the partition table and the blink demo execute the command:

esptool.py --chip esp32s3 --port [YOUR_PORT] --baud 921600 --before default_reset --after hard_reset write_flash -z --flash_mode dio --flash_freq 80m --flash_size detect 0x0 bootloader.bin 0x8000 partitions.bin 0x10000 polverine_blink.bin

If the blink application does not start, the press the reset (EN/SW2) button.

If the Polverine device resets periodically, then start the bootloader:

  1. press the SW1/BOOT button
  2. press the SW2/EN button
  3. release  the SW2/EN button
  4. release SW1/BOOT button

Connect to Polverine

Polverine includes firmware that, when connected to the PC's USB port, creates a serial connection through which it writes data collected from the BMV080 sensor.

You can use any Windows terminal application (such as Termite or TeraTerm) to view the data being read. Since it's a USB connection, parameters like speed and parity are irrelevant.

If this is the first time you're connecting an ESP32 device, your computer (Windows) will need to download the appropriate drivers. This will happen automatically, and you'll receive a notification when it's ready. You can verify the presence of a new USB port in the Windows Device Manager.

Polverine is also compatible with Mac and Linux systems. If you have an Android phone or tablet, or an Apple device that supports the USB OTG standard, Polverine can be connected using an appropriate cable.

For Android devices, you can use the Serial USB Terminal app.

The USB connection also serves as a debugger. If, after connecting Polverine to the terminal, you see a request to download firmware, simply press the EN/SW2 button and restart the terminal program.


 Complete Solution for Sensor Data Collection and Analysis

At the heart of this solution lies custom open-source firmware designed specifically for Polverine devices. This firmware collects sensor measurements and transmits them using the ESP32-S3 module's WiFi capabilities to an MQTT broker. From there, a NodeRed "Server Flow" monitors the broker's message queue and systematically archives all incoming data in a MongoDB database.

Polverine Software Flow

The system also benefits from the latest SDK for the BMV080 sensor, which is now publicly available. This SDK enables the reading of particulate matter (PM) values for PM10, PM2.5, and PM1. The full range of sensed quantities includes:

  • Temperature
  • Relative Humidity
  • Barometric Pressure
  • Volatile Organic Compounds (V.O.C.)
  • Particulate Matter 10 (PM10)
  • Particulate Matter 2.5 (PM2.5)
  • Particulate Matter 1 (PM1)
In addition to local sensor data, the server-side processing layer integrates with OpenWeatherMap's API to enrich the dataset with external environmental parameters such as temperature, humidity, barometric pressure, wind speed, and cloud cover percentages.

For more information link to Polverine's GtiHub Repo

© Copyright 2020 BlackIoT Sagl - All Rights Reserved