Arduino Movement Sensors with Adafruit Feather ESP32

; PlatformIO Project Configuration File
;
;   Build options: build flags, source filter
;   Upload options: custom upload port, speed and extra flags
;   Library options: dependencies, extra library storages
;   Advanced options: extra scripting
;
; Please visit documentation for the other options and examples
; https://docs.platformio.org/page/projectconf.html
[platformio]
default_envs = receiver

[common]
platform = espressif32
board = adafruit_feather_esp32_v2
framework = arduino
monitor_speed = 115200
build_unflags = -std=gnu++11
build_flags = -std=gnu++17
lib_deps = https://github.com/arduino-libraries/Arduino_Modulino


; ==== Receiver node ====
[env:receiver]
extends = common
build_src_filter = +<main_receiver.cpp>

; ==== IMU sensor node ====

[env:imu-sensor]
extends = common
build_src_filter = +<main_imu.cpp>

[env:detect-mac]
extends = common
build_src_filter = +<detect_mac.cpp>

// common.hpp

constexpr uint8_t receiver_mac[] = {0xF4, 0x65, 0x0B, 0x33, 0x2D, 0x40};

typedef struct imu_data {
  uint8_t id;
  float x;
  float y;
  float bat;
} imu_data;

// detect_mac.cpp
/*
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at https://RandomNerdTutorials.com/get-change-esp32-esp8266-mac-address-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include <Arduino.h>
#include <WiFi.h>
#include <esp_wifi.h>

void readMacAddress(){
  uint8_t baseMac[6];
  esp_err_t ret = esp_wifi_get_mac(WIFI_IF_STA, baseMac);
  if (ret == ESP_OK) {
    Serial.printf("%02x:%02x:%02x:%02x:%02x:%02x\n",
                  baseMac[0], baseMac[1], baseMac[2],
                  baseMac[3], baseMac[4], baseMac[5]);
  } else {
    Serial.println("Failed to read MAC address");
  }
}

void setup(){
  Serial.begin(115200);
  while(!Serial);

  delay(1000);
  Serial.print("HEY");

  WiFi.mode(WIFI_STA);
  WiFi.begin();
  // WiFi.STA.begin();

  Serial.print("[DEFAULT] ESP32 Board MAC Address: ");
  readMacAddress();
}

void loop(){

  Serial.print("[DEFAULT] ESP32 Board MAC Address: ");
  readMacAddress();
  delay(1000);
}

pio run -e detect-mac -t upload --upload-port /dev/ttyACM0

pio device monitor --baud 115200 --port /dev/ttyACM0

#include <Arduino.h>
#include <esp_now.h>
#include <WiFi.h>
#include "common.hpp"

// callback function that will be executed when data is received
void OnDataRecv(const uint8_t * mac, const uint8_t *incomingData, int len) {

  // Unpack and print
    imu_data data;
    memcpy(&data, incomingData, sizeof(data));
    Serial.print(data.id, 1);
    Serial.print(" ");
    Serial.print(data.x, 6); // 6 decimal places for float
    Serial.print(" ");
    Serial.print(data.y, 6);
    Serial.print(" ");
    Serial.print(data.bat);
    Serial.print("\n");
}

void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);

  // Set device as a Wi-Fi Station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for recv CB to
  // get recv packer info
  esp_now_register_recv_cb(esp_now_recv_cb_t(OnDataRecv));
}
// No need for anything in the loop function, as everything is taken care of by the
// callback function
void loop() { }

pio run -e receiver -t upload --upload-port /dev/ttyACM0

#include <Arduino.h>
#include "Modulino.h"
#include "common.hpp"
#include <esp_now.h>
#include <WiFi.h>

// Create a ModulinoMovement
ModulinoMovement movement;


// ID, x, y, battery. The ID is a unique integer for each of the sensor nodes.
imu_data data = { static_cast<uint8_t>(2), 0.0f, 0.0f, 0.0f }; 

esp_now_peer_info_t peerInfo;

// callback when data is sent. I use this only for debugging. 
// When I am sure that the connection is fine I comment it out.
void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.print("\r\nLast Packet Send Status:\t");
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
}

// The accelerometer data for x and y is scaled to the range [-1.0 .. 1.0].
// I prefer it to be in the range [0..1] instead.
float normalizeAccData(float in) {
  in += 1.0f;
  in /= 2.0f;
  // Ensure we never go outside the range
  return std::clamp(in, 0.0f, 1.0f);
}

void setup() {
  Serial.begin(115200); // baud rate
  // Set device as a wifi station
  WiFi.mode(WIFI_STA);

  // Init ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }

  // Once ESPNow is successfully Init, we will register for Send CB to
  // get the status of Transmitted packet. Uncomment for debugging.
  // esp_now_register_send_cb(OnDataSent); 

  // Register peer
  memcpy(peerInfo.peer_addr, receiver_mac, 6);
  // Use default channel
  peerInfo.channel = 0;
  peerInfo.encrypt = false;

  // Add peer
  if (esp_now_add_peer(&peerInfo) != ESP_OK){
    Serial.println("Failed to add peer");
    return;
  }

  // Initialize Modulino I2C communication
  Modulino.begin();
  // Detect and connect to movement sensor module
  movement.begin();

}

float prevXY[2] = { 0.0f, 0.0f };

void loop() {
  // Read new movement data from the sensor
  movement.update();

  // Get acceleration values
  data.x = normalizeAccData(movement.getX());
  data.y = normalizeAccData(movement.getY());

  // Get battery levels
  const float rawADC = analogReadMilliVolts(A13);
  const float currentVoltage = (rawADC * 2.0f) / 1000.0f;
  data.bat = currentVoltage;

  // Calculate delta value to determine when to send out data
  const float delta = (fabs(data.x - prevXY[0]) + fabs(data.y - prevXY[1])) / 2.0f;
  prevXY[0] = data.x;
  prevXY[1] = data.y;

  // Send message via ESP-NOW only when the sensor is in motion. 
  // This should extend the battery life significantly
  if (delta > 0.005) {
    esp_err_t result = esp_now_send(receiver_mac, (uint8_t *) &data, sizeof(data));

  }

  delay(50);
}

(let ((open-p nil))
  (defun start-serial (&optional (port *serial-port*))
    (setf open-p t)
    (setf *serial-port* port)
    (bt:make-thread
     (lambda ()
       (serial:with-serial-device
           (device serial:serial-device-input
                   :name port
                   :baudrate 115200)
         (format t "Opening serial port ~a~%" port)
         (let ((stream (flexi-streams:make-flexi-stream device)))
           (loop while (and stream open-p) do
             (let ((line (read-line stream)))
               (if (= (length line) 24)
                   (let ((id (parse-integer (subseq line 0 1))))
                     (set-x id (parse-float:parse-float (subseq line 2 10)))
                     (set-y id (parse-float:parse-float (subseq line 11 19)))
                     (set-bat id (parse-float:parse-float (subseq line 20)))))))
           (format t "Closing serial port ~a~%" port))
         :name "Serial from sensor"))))
  (defun stop-serial ()
    (setf open-p nil)))