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.

You can download the Polverine board schematic and 3D step file from DOCS folder in our GitHub Repository.

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

ESP32 GPIO ESP32 Function Name Pin on Interface Interface
IO0 BOOT0 BOOT0 ESP_IO0 SW1 Button
IO1 ADC1_CH0 MikroBUS AN 1L mikroBUS
IO2 PWM MikroBUS PWM 1R mikroBUS
IO3 Strapping n.c. n.c. n.c.
IO4 Strapping n.c. n.c. n.c.
IO5 IRQ Input BMV080 INT 12 BMV080
IO6 n.c. n.c. n.c. n.c.
IO7 INT MikroBUS INT 2R mikroBUS
IO8 I2C1 SDA MikroBUS SDA 6R mikroBUS/QWIIC
IO9 I2C1 SCL MikroBUS SCL 5R mikroBUS/QWIIC
IO10 SPI2 CS0 BMV080 CSn Pin4 BMV080
IO11 SPI2 MOSI BMV080 MOSI Pin5 BMV080
IO12 SPI2 SCLK BVM080 SCK Pin6 BMV080
IO13 SPI2 MISO BMV080 MISO Pin 11 BMV080
IO14 I2C2 SDA SDI 3 BME690
IO15 Onboard RTC clock n.c. n.c. n.c.
IO16 Onboard RTC Clock n.c. n.c. n.c.
IO17 U1TXD MikroBUS/TX 4R mikroBUS
IO18 U1RXD MicroBUS/RX 3R mikroBUS
IO19 Onboard USB D- USB DM
USB
IO20 Onboard USB D+ USB DP
USB
IO21 I2C2 SCL SCK 4 BME690
IO33 n.c. n.c. n.c. PSRAM
IO34 SPI3 CS0 MikroBUS/CS 3L mikroBUS/PSRAM
IO35 SPI3 MOSI MikroBUS/MOSI 6L mikroBUS/PSRAM
IO36 SPI3 SCK MikroBUS/SCK 4L mikroBUS/PSRAM
IO37 SPI3 MISO MikroBUS/MISO 5L mikroBUS/PSRAM
38 PWM OUT PWM RGBLED_R
 RED LED
39 Onboard JTAG TCK JTAG ESP_TCK JTAG IF
40 Onboard JTAG TDO JTAG ESP_TDO JTAG IF
41 Onboard JTAG TDI JTAG ESP_TDI JTAG IF
42 Onboard JTAG TMS JTAG ESP_TMS JTAG IF
U0RXD UART RX Serial ESP_RXD Program IF
U0TXD UART TX Serial ESP_TXD Program IF
45 Strapping n.c. n.c. n.c.
46 Strapping n.c. n.c. n.c.
47 PWM OUT PWM RGBLED_G
 GREEN LED
48 PWM OUT PWM RGBLED_B
 BLUE LED
RST Reset MikroBUS/RST 2L mikroBUS
EN/CHIP_PU Enable
ESP_EN Program IF
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

Arduino IDE

Polverine board is fully compatible with the Arduino IDE. To use it, install the ESP32 support package by Espressif Systems, and select "ESP32S3 Dev Module" as the board in the IDE.

Debugging features are fully supported.

To begin programming, use the ARDUINO_BLINK example. For sensor integration, download the SDKs for the BME690 and BMV080 sensors from the Bosch Sensortec website.

For more information link to Polverine's GtiHub Repo

© Copyright 2020 BlackIoT Sagl - All Rights Reserved

linkedin