Esp32 connection to SignalK

[FluroYellow]

Hi Team

I am trying to put some sensors into my boat and a couple of them I am using a esp32. I haven't been able to locate a complete/ relevant guide to do what I need to do, some get me half the way there but not quite.
I have signalK running and 3 dallas 1 wire temp sensors are connected to the gpio on the raspberry pi and work great, gps on the pi works great.

Initially I was using the Arduino ide to upload some sketches to the esp32 and I managed to get it on the network, but it would not get to the point of a access request. I then tried using visual code studio and platformio, initally I could not get the connection to work via manual config but after wiping the esp32 and running the build process again, I was able to browse to its web server and connect it to the correct wifi network and then got an access request from signalk.

My code I have used a template, but had to comment a lot of things out that are not connected. I have connected a dallas 1 wire to the esp32 but am yet to get its path through to signalk - pretty sure its my code.

My main things I want to do with the 2 esp 32's is :

#1 4 temp sensors
#2 Rudder angle indicator, I have the KUS dual station angle sensor

Do I have to use platformio ?

Can anyone direct me to a template for what I am trying to do here ? Or a tutorial to help me build the code I need.

[tkurki]

https://signalk.org/SensESP/ should provide answers to your use case.

[FluroYellow]

I had already been through that, but found it to be missing a bit of info. I guess I will just fish around or move to using the home assistant platform

[FluroYellow]

Ok so What I am trying to do is fairly simple. the documentation has some non relevant examples that are not useful to me . I have the wroom32 esp boards. all I want is for one of the ESP's to have 4 ds18b20 temp sensors - and send that temp data to my signalk server. the other ESP 32 I want it to read a resistance value from a rudder angle sensor and then send the data to the signalk server. Should be fairly simple for someone with some experience. Currently not having any luck and the documentation is quite vague

[tkurki]

https://github.com/SensESP/OneWire does exactly what you want for temperature, what is missing?

[FluroYellow]

Ok for instance this file onewire_temperature.h - where do i define the pin that the data wire of the ds18b20's are connected? Theres comments to set @param pin - but there is no infor related to where do I enter this and in what format? I have the data wire on pin 25 of the esp32

---

#ifndef SENSESP_SENSORS_ONEWIRE_H
#define SENSESP_SENSORS_ONEWIRE_H

#include

#include "OneWireNg.h"
#include "drivers/DSTherm.h"

#include "sensesp/sensors/sensor.h"

namespace sensesp {

typedef std::array<uint8_t, 8> OWDevAddr;

/**

• @brief Finds all 1-Wire temperature sensors that are connected
• to the ESP and makes the address(es) and temperature data available
• to the OneWireTemperature class.
• This class has no pre-defined limit on the number of 1-Wire sensors
• it can work with. From a practical standpoint, it should handle all
• the sensors you're likely to connect to a single ESP.
• @param pin The GPIO pin to which you have the data wire of the
• 1-Wire sensor(s) connected.
• @param config_path Currently not used for this class, don't provide
• it - it defaults to a blank String.
  */
  class DallasTemperatureSensors : public Sensor {
  public:
  DallasTemperatureSensors(int pin, String config_path="");
  void start() override final {}
  bool register_address(const OWDevAddr& addr);
  bool get_next_address(OWDevAddr addr);
  DSTherm get_dallas_driver() { return DSTherm{onewire_}; }
  private:
  OneWireNg onewire_;
  std::set known_addresses_;
  std::set registered_addresses_;
  };

/**

• @brief Used to read the temperature from a single 1-Wire temperature
• sensor. If you have X sensors connected to your ESP, you need to create
• X instances of this class in main.cpp.
• All instances of this class have
• a pointer to the same instance of DallasTemperatureSensors.
• Temperature is read in Celsius, then converted to Kelvin before sending
• to Signal K.
• It will use the next available sensor address from all those found by the
• DallasTemperatureSensors class. Once a sensor is "registered" by this class,
• it will keep reading that sensor (by its unique hardware address) unless you
• change the address in the Config UI.
• @see https://github.com/SignalK/SensESP/tree/master/examples/thermocouple_temperature_sensor
• @param dts Pointer to an instance of a DallasTemperatureSensors class.
• @param read_delay How often to read the temperature. It takes up to 750 ms for the data
• to be read by the chip, so this parameter can't be less than 800. If you make it less than
• 800, the program will force it to be 800. You should
• probably make it 1000 (the default) or more, to be safe.
• @param config_path The path to configure the sensor address in the Config UI.
  */
  class OneWireTemperature : public FloatSensor {
  public:
  OneWireTemperature(DallasTemperatureSensors dts, uint read_delay = 1000,
  String config_path="");
  void start() override final;
  virtual void get_configuration(JsonObject& doc) override final;
  virtual bool set_configuration(const JsonObject& config) override final;
  virtual String get_config_schema() override;

private:
DallasTemperatureSensors* dts_;
uint conversion_delay_ = DSTherm::MAX_CONV_TIME;
uint read_delay_;
bool found_ = true;
OWDevAddr address_ = {};
void update();
void read_value();
};

} // namespace sensesp

#endif

[FluroYellow]

then you have the onewire_temperature.cpp

It also mentions pins ? which file do i define the pins in and how ?

---

#include

#include "onewire_temperature.h"

#include "OneWireNg_CurrentPlatform.h"
#include "utils/Placeholder.h"

#define DEVICE_DISCONNECTED_C -127

namespace sensesp {

const OWDevAddr null_ow_addr = {0, 0, 0, 0, 0, 0, 0, 0};

void owda_to_string(char* str, const OWDevAddr& addr) {
// brute force it
sprintf(str, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", addr[0], addr[1],
addr[2], addr[3], addr[4], addr[5], addr[6], addr[7]);
}

bool string_to_owda(OWDevAddr* addr, const char* str) {
// brute force it
uint vals[8];
int num_items =
sscanf(str, "%02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x", &vals[0], &vals[1],
&vals[2], &vals[3], &vals[4], &vals[5], &vals[6], &vals[7]);
for (int i = 0; i < 8; i++) {
(*addr)[i] = vals[i];
}
return num_items == 8;
}

DallasTemperatureSensors::DallasTemperatureSensors(int pin, String config_path)
: Sensor(config_path) {
onewire_ = new OneWireNg_CurrentPlatform(
pin,
false // disable internal pull-up
);
DSTherm drv{*onewire_};

#if (CONFIG_MAX_SRCH_FILTERS > 0)
static_assert(CONFIG_MAX_SRCH_FILTERS >= DSTherm::SUPPORTED_SLAVES_NUM,
"OneWireNg config: CONFIG_MAX_SRCH_FILTERS too small");
#else

error "OneWireNg config: CONFIG_MAX_SRCH_FILTERS not defined"

#endif

// in the process of 1-wire bus scan
// filter out supported Dallas sensors
drv.filterSupportedSlaves();

OWDevAddr owda;

for (const auto& addr: *onewire_) {
std::copy(std::begin(addr), std::end(addr), std::begin(owda));
known_addresses_.insert(owda);
#ifndef DEBUG_DISABLED
char addrstr[24];
owda_to_string(addrstr, owda);
debugI("Found OneWire sensor %s", addrstr);
#endif
// Set common max. resolution (12-bits) for all handled sensors.
// The configuration will be valid until subsequent power cut-off.
drv.writeScratchpad(
addr,
0, 0, // disable alarm notifications
DSTherm::RES_12_BIT
);
}
}

bool DallasTemperatureSensors::register_address(const OWDevAddr& addr) {
auto search_known = known_addresses_.find(addr);
if (search_known == known_addresses_.end()) {
// address is not known
return false;
}
auto search_reg = registered_addresses_.find(addr);
if (search_reg != registered_addresses_.end()) {
// address is already registered
return false;
}

registered_addresses_.insert(addr);
return true;
}

bool DallasTemperatureSensors::get_next_address(OWDevAddr* addr) {
// find the next address from known_addresses which is
// not present in registered_addresses
for (auto known : known_addresses_) {
auto reg_it = registered_addresses_.find(known);
if (reg_it == registered_addresses_.end()) {
*addr = known;
return true;
}
}
return false;
}

OneWireTemperature::OneWireTemperature(DallasTemperatureSensors* dts,
uint read_delay, String config_path)
: FloatSensor(config_path), dts_{dts}, read_delay_{read_delay} {
load_configuration();
if (address_ == null_ow_addr) {
// previously unconfigured sensor
bool success = dts_->get_next_address(&address_);
if (!success) {
debugE(
"FATAL: Unable to allocate a OneWire sensor for %s. "
"All sensors have already been configured. "
"Check the physical wiring of your sensors.",
config_path.c_str());
found_ = false;
} else {
debugD("Registered a new OneWire sensor");
dts_->register_address(address_);
}
} else {
bool success = dts_->register_address(address_);
if (!success) {
char addrstr[24];
owda_to_string(addrstr, address_);
debugE(
"FATAL: OneWire sensor %s at %s is missing. "
"Check the physical wiring of your sensors.",
config_path.c_str(), addrstr);
found_ = false;
}
}
}

void OneWireTemperature::start() {
if (found_) {
// read_delay must be at least a little longer than conversion_delay
if (read_delay_ < conversion_delay_ + 50) {
read_delay_ = conversion_delay_ + 50;
}
ReactESP::app->onRepeat(read_delay_, this { this->update(); });
}
}

void OneWireTemperature::update() {
dts_->get_dallas_driver().convertTemp(
*reinterpret_castOneWireNg::Id*(address_.data()),
0 // don't wait for conversion
);

// temp converstion can take up to 750 ms, so wait before reading
ReactESP::app->onDelay(conversion_delay_, this { this->read_value(); });
}

void OneWireTemperature::read_value() {
PlaceholderDSTherm::Scratchpad scrpd;
float tempC = DEVICE_DISCONNECTED_C;

if (dts_->get_dallas_driver().readScratchpad(
*reinterpret_castOneWireNg::Id*(address_.data()),
&scrpd) == OneWireNg::EC_SUCCESS) {
tempC = ((DSTherm::Scratchpad&)scrpd).getTemp() / 1000.0;
}

// we're on purpose ignoring the "conversion not ready" value (+85°C)
// because the update method always waits for 750 ms before reading the value
if (tempC == DEVICE_DISCONNECTED_C) {
char ow_addr_str[24];
owda_to_string(ow_addr_str, address_);
debugW("Failed to read 1-Wire device %s", ow_addr_str);
return;
}
// getTempC returns degrees Celsius but Signal K expects Kelvin
this->emit(tempC + 273.15);
}

void OneWireTemperature::get_configuration(JsonObject& root) {
char addr_str[24];
owda_to_string(addr_str, address_);
root["address"] = addr_str;
root["found"] = found_;
}

static const char SCHEMA[] PROGMEM = R"({
"type": "object",
"properties": {
"address": { "title": "OneWire address", "type": "string" },
"found": { "title": "Device found", "type": "boolean", "readOnly": true }
}
})";

String OneWireTemperature::get_config_schema() { return FPSTR(SCHEMA); }

bool OneWireTemperature::set_configuration(const JsonObject& config) {
if (!config.containsKey("address")) {
return false;
}
string_to_owda(&address_, config["address"]);
return true;
}

} // namespace sensesp

---

[tkurki]

Now that you've copypasted all the library code in the repository that does not contain the answers maybe consider

• looking at the example code and its documentation, with very nice step by step instructions, at https://github.com/SensESP/OneWire/tree/main/examples/onewire_temperature
• next time try searching the repo for a keyword like pin

(yes, the link in the readme to the example file is not working, but with a tiny bit of detective work you could have found what you are looking for)

[FluroYellow]

This is a great example actually of how the documentation is missing detail. - https://github.com/SensESP/OneWire/raw/main/examples/onewire_temperature/images/define_sensor_pin.png this detail here is formatted different than in the actual example code

How do i set the pin in the code below from the template, here using the above instructions, they are completely different ? Is it just the number 25 after the , i.e pin,25 or is it pin, (25)

DallasTemperatureSensors::DallasTemperatureSensors(int pin, String config_path)
: Sensor(config_path) {
onewire_ = new OneWireNg_CurrentPlatform(
pin,
false // disable internal pull-up
);
DSTherm drv{*onewire_};

[tkurki]

This is a great example of trying to provide help but the reader stubbornly looking at the wrong thing.

That is not the code you are looking for. Your code is not from the example code.

[FluroYellow]

Trying to follow instructions, but when they arent there, ie the readme that was missing, it makes it a little difficult.. Ok so I have wiped the esp32, started again with the example code, chopped it down to one sensor , told it to look at pin 25 - the esp32 is authorized and connected to the signalk server, but cant see the data in the data browser from the sensor, When i visit the web browser of the esp32, I dont have the sensors in the web menu as shown in the image to verify if they are connected - any ideas here
? https://github.com/SensESP/OneWire/raw/main/examples/onewire_temperature/images/sensesp_config_page2.png

#include "sensesp/signalk/signalk_output.h"
#include "sensesp/transforms/linear.h"
#include "sensesp_app_builder.h"
#include "sensesp_onewire/onewire_temperature.h"

using namespace sensesp;

ReactESP app;

void setup() {
#ifndef SERIAL_DEBUG_DISABLED
SetupSerialDebug(115200);
#endif

// Create the global SensESPApp() object.
SensESPAppBuilder builder;
sensesp_app = builder.get_app();

/*
Find all the sensors and their unique addresses. Then, each new instance
of OneWireTemperature will use one of those addresses. You can't specify
which address will initially be assigned to a particular sensor, so if you
have more than one sensor, you may have to swap the addresses around on
the configuration page for the device. (You get to the configuration page
by entering the IP address of the device into a browser.)
*/

/*
Tell SensESP where the sensor is connected to the board
ESP32 pins are specified as just the X in GPIOX
*/
uint8_t pin = 25;

DallasTemperatureSensors* dts = new DallasTemperatureSensors(pin);

// Define how often SensESP should read the sensor(s) in milliseconds
uint read_delay = 500;

// Below are temperatures sampled and sent to Signal K server
// To find valid Signal K Paths that fits your need you look at this link:
// https://signalk.org/specification/1.4.0/doc/vesselsBranch.html

// Measure coolant temperature
auto* coolant_temp =
new OneWireTemperature(dts, read_delay, "/coolantTemperature/oneWire");

coolant_temp->connect_to(new Linear(1.0, 0.0, "/coolantTemperature/linear"))
->connect_to(new SKOutputFloat("propulsion.mainEngine.coolantTemperature",
"/coolantTemperature/skPath"));

// Configuration is done, lets start the readings of the sensors!
sensesp_app->start();
}

// main program loop
void loop() { app.tick(); }

[tkurki]

I am not much of a hardware hacker (I have the sum total of one esp32 installed right now), but if I were you I would

• verify the physical connections and check the pull up resistor
• check with differerent sensors (if you have multiple)
• verify that esp-sensor connection is working with the simplest software I could find (example)

If things still don't work I'd join the SK Slack ("click here for invite") and #sensors channel there for more support.

[tkurki]

So, did you get it working?

[bradharley]

Are you still working on this? While not a developer, I have some experience with ESP32's. I would approach this incrementally to understand all the functions. I would:

• first start with getting the temp sensor working with the dallas libraries. There are really good examples in the library itself.
• Second, get senseESP working on your esp with some garbage data.
• Merge the two together.
  As an alternate, you can use mqtt on the ESP and grab that with node red. I personally do that as I started before senseESP was a thing, and I started on an Arduino Mega. IT's probably easier, though less graceful.

[FluroYellow]

Hi Guys,

Have sort of hit a wall , I changed over to Jasons code - https://github.com/Techstyleuk/sensesp-engine_monitor I have senseesp working, it connects to my raspi signalk server, however, it does not detect the dallas sensors.. I've been working on rebuilding the starter motor solenoid on my boat and sorting some cooling issues on my 4hp outboard so have got a bit sidetracked.

I get the below when the esp32 starts up
-- Terminal on COM4 | 115200 8-N-1
--- Available filters and text transformations: colorize, debug, default, direct, esp32_exception_decoder, hexlify, log2file, nocontrol, printable,
send_on_enter, time
--- More details at https://bit.ly/pio-monitor-filters
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H
e(SetupSerialDebug)(C1)
Serial debugging enabled
(load_configuration)(C1) Not loading configuration: no config_path specified:
(load_configuration)(C1) Loading configuration for path '/System/WiFi Settings' from '/1y6oPD6lHzs1o19UpJFFjbslZu8='
(load_configuration)(C1) Loading configuration for path '/System/Signal K Settings' from '/7NAVR03_FL3ag9_pt1mBQlpDmeM='
(load_configuration)(C1) Not loading configuration: no config_path specified:
(load_configuration)(C1) Could not find configuration for path /Oil Temperature/oneWire
(OneWireTemperature)(C1) FATAL: Unable to allocate a OneWire sensor for /Oil Temperature/oneWire. All sensors have already been configured. Check the physical wiring of your sensors.
(load_configuration)(C1) Could not find configuration for path /Oil Temperature/linear
(load_configuration)(C1) Could not find configuration for path /Oil Temperature/sk_path
(SKOutputNumeric)(C1) WARNING - No metadata for propulsion.engine.oilTemperature. Numeric values should specify units
(load_configuration)(C1) Could not find configuration for path /Aft Cabin Temperature/oneWire
(OneWireTemperature)(C1) FATAL: Unable to allocate a OneWire sensor for /Aft Cabin Temperature/oneWire. All sensors have already been configured. Check the physical wiring of your sensors.
(load_configuration)(C1) Could not find configuration for path /Aft Cabin Temperature/linear
(load_configuration)(C1) Could not find configuration for path /Aft Cabin Temperature/sk_path
(SKOutputNumeric)(C1) WARNING - No metadata for environment.inside.aftCabin.temperature. Numeric values should specify units

I do have the 38pin esp wroom32 and a breakout board with it, im 99% sure I have the right gpio pin.
I actually was thinking about this yesterday while taking my waverunner for a blast, wondering how many amps the esp 32 needs and if I need to change to a different power supply.

[seandepagnier]

Just as a note, I've implemented signalk support from scratch in my new project:
https://github.com/pypilot/pypilot_mfd

It should be good to have multiple implementations of signalk interfaces for esp32 exercising different code paths and different underlying libraries hopefully this strengthens support!