libresolar / esp32-edge-firmware

Firmware for CAN/UART to WiFi/BLE gateway using ESP32

Libre Solar ESP32 Edge Firmware

Firmware for CAN and UART to WiFi or Bluetooth gateway based on ESP32-IDF v4.0.

Warning: This firmware is at a very early stage. Expect bugs and report them in the issues :)

Concept Overview

The firmware should support multiple use-cases to connect Libre Solar devices with other networks (incl. the internet).

ESP32 acting as an Edge Gateway to the cloud

In this application, the ESP32 is integrated in a separate device (like the Libre Solar Data Manager) and communicates with the other devices like the charge controller via CAN bus.

The ThingSet protocol on the CAN bus can translated to MQTT in order to push data to a cloud. For local access, the ESP32 can directly serve a website or provide a Bluetooth Low Energy interface for a mobile phone app.

ESP32 integrated in device (e.g. charge controller)

The ESP32 board can also be directly integrated in a charge controller or other devices and communicate with the host device via UART interface (again using the ThingSet protocol).

The data can be accessed in the same way as described above.

Supported devices

• Libre Solar Data Manager
• Sparkfun ESP32thing
• Most other ESP32-based boards

Firmware features

• Written in C using ESP-IDF and PlatformIO
• Data input from Libre Solar devices via
  • LS.bus (CAN bus)
  • LS.one (UART serial)
• Local communication via ThingSet Protocol
• Data access via HTTP JSON API
• Publishing of monitoring data via WiFi to
  • Open Energy Monitor Emoncms
  • MQTT server (ToDo)
• Data logging on SD card (ToDo)

Usage

Getting the firmware

This firmware repository contains git submodules, so you need to clone (download) it by calling:

git clone --recursive https://github.com/LibreSolar/esp32-edge-firmware

Unfortunately, the green GitHub "Clone or download" button does not include submodules. If you cloned the repository already and want to pull the submodules, run git submodule update --init --recursive.

Building the webapp

To be able to build the esp32-edge-firmware you need to build the webapp first. To do so, go into the webapp folder

    cd esp32-edge-firmware/webapp

and run

    npm install
    npm run build

You are now able to build the firmware itself.

ESP-IDF toolchain

The ESP-IDF is the native toolchain for ESP32 microcontrollers by Espressif. Follow this guide to install it.

After installation run the following commands:

idf.py build            # compile the firmware
idf.py flash            # flash it to the device

PlatformIO

You can use PlatformIO for easy building and flashing. However, the PlatformIO packages for ESP-IDF are not updated as frequently as the official repositories.

Configuration

The firmware is configured using Kconfig integrated into ESP-IDF.

The most convenient way is to run idf.py menuconfig after the ESP-IDF was successfully installed. If ESP-IDF is not available and PlatformIO is used, configuration can be changed manually in the generated sdkconfig file.

Wifi Connection

The firmware supports provisioning via bluetooth. You can download the espressif BLE provisioning app in the iOS or android app store and scan this QR code:

You can also scan for the device manually in the app, the data manager should be found as device PROV_LS-DM, the service pin is LibreSolar.

esp32-edge-firmware's Issues

GET handler

Write handler to create endpoints for GET requests.

A user (ie. a web app) should be able to get a response when requesting endpoints matching the thingset data structure. A successful request means that the endpoint exists (ie. /data/output/Bat_V or /pub/Bat_A). With a successful request the user should receive a json response, otherwise a 40x status code.

Implement a way to change wifi parameters

When the Wifi is provisioned, there is no way to reset it and restart the provision manager.
Implement a way to recover in case the SSID or PW changed

Introduce ports to handle tasks like device scan in a generic way

Currently there are special functions to scan for devices on serial and can ports. In my case the devices are connected by SPI. So I would have to add another special function and do some code duplication.

Instead introduce ports that have general functions to scan for devices that are connected to the ports and also for other functions. The ports may be modeled (similar to devices) with a generic structure that can be filled with the the special functions for a specific type of port. The structure should ideally be constant to not consume precious RAM in constrained devices.

The concept of port may be not only applied to downstream links but also to upstream links.

Implement UART ThingSet client

Basic driver is implemented.
The server needs to have access to Thingset data. First step is implementing reading text mode serial data.