Recording data from two adxl345 sensors

If you send 3 of them ayway, then merge them in max.

Make sense. I will do so.

edit:

is this valid way to merge the 3 axes?

expr (abs($f1-0.5)+abs($f2-0.5)+abs($f3-0.5))/3.

can you post that little part of your code where you get that pause reported.

you mean the part in MAX?

Max part:

Here is the full sender code without the merge.

#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_ADXL345_U.h>
#include <WiFi.h>
#include <esp_now.h>

Adafruit_ADXL345_Unified accel1 = Adafruit_ADXL345_Unified(1);

const float THRESHOLD = 0.1;
const float RANGE = 2.0;   // TUNE THIS: increase if values clip at 0 or 1
const float ALPHA = 0.2;
const int CALIBRATION_SAMPLES = 400;
const int CALIBRATION_DELAY = 10;

unsigned long lastTx = 0;
const unsigned long TX_INT = 10;

uint8_t receiverMAC[] = { 0x68, 0xEE, 0x8F, 0x46, 0x4E, 0x34 };

typedef struct {
  uint8_t id;
  float value;
} SensorPacket;
SensorPacket dataToSend;
bool sensor1ok = false;

struct SensorState {
  float centerX = 0, centerY = 0, centerZ = 9.8;
  float prevX = 0.5, prevY = 0.5, prevZ = 0.5;
  float filtX = 0.5, filtY = 0.5, filtZ = 0.5;
};
SensorState s1;

#define LED_PIN LED_BUILTIN
bool ledState = false;
unsigned long lastLedToggle = 0;
unsigned long lastAckTime = 0;
const unsigned long COMM_TIMEOUT = 2000;
const unsigned long BLINK_WAITING = 300;
const unsigned long BLINK_ACTIVE = 1000;

const unsigned long HEARTBEAT_INTERVAL = 500;
unsigned long lastHeartbeat = 0;
SensorPacket heartbeatPacket;

#if defined(ESP_ARDUINO_VERSION_MAJOR) && ESP_ARDUINO_VERSION_MAJOR >= 3
void onSent(const esp_now_send_info_t *info, esp_now_send_status_t status) {
  if (status == ESP_NOW_SEND_SUCCESS) { lastAckTime = millis(); }
}
#define REG_CB esp_now_register_send_cb((esp_now_send_cb_t)onSent)
#else
void onSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  if (status == ESP_NOW_SEND_SUCCESS) { lastAckTime = millis(); }
}
#define REG_CB esp_now_register_send_cb(onSent)
#endif

void calibrate() {
  float sx = 0, sy = 0, sz = 0;
  for (int i = 0; i < CALIBRATION_SAMPLES; i++) {
    sensors_event_t event;
    if (sensor1ok) {
      accel1.getEvent(&event);
      sx += event.acceleration.x;
      sy += event.acceleration.y;
      sz += event.acceleration.z;
    }
    delay(CALIBRATION_DELAY);
  }
  if (sensor1ok) {
    s1.centerX = sx / CALIBRATION_SAMPLES;
    s1.centerY = sy / CALIBRATION_SAMPLES;
    s1.centerZ = sz / CALIBRATION_SAMPLES;
  }
}

void setup() {
  pinMode(LED_PIN, OUTPUT);
  digitalWrite(LED_PIN, LOW);

  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) {
    while (1)
      ;
  }
  REG_CB;
  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, receiverMAC, 6);
  peerInfo.channel = 0;
  peerInfo.encrypt = false;
  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    while (1)
      ;
  }
  Wire.begin();
  Wire.setClock(400000);
  sensor1ok = accel1.begin(0x53);
  if (sensor1ok) {
    accel1.setRange(ADXL345_RANGE_2_G);
    accel1.setDataRate(ADXL345_DATARATE_100_HZ);
  }
  calibrate();
  setCpuFrequencyMhz(80);
}

void loop() {
  unsigned long now = millis();
  bool commActive = (now - lastAckTime) < COMM_TIMEOUT;
  unsigned long blinkInterval = commActive ? BLINK_ACTIVE : BLINK_WAITING;
  if (now - lastLedToggle >= blinkInterval) {
    ledState = !ledState;
    digitalWrite(LED_PIN, ledState);
    lastLedToggle = now;
  }

  if (now - lastHeartbeat >= HEARTBEAT_INTERVAL) {
    heartbeatPacket.id = 99;
    heartbeatPacket.value = 0;
    esp_now_send(receiverMAC, (uint8_t *)&heartbeatPacket, sizeof(SensorPacket));
    lastHeartbeat = now;
  }

  if (sensor1ok) {
    sensors_event_t event;
    accel1.getEvent(&event);

    float nx = constrain(0.5 + (event.acceleration.x - s1.centerX) / (2.0 * RANGE), 0.0, 1.0);
    float ny = constrain(0.5 + (event.acceleration.y - s1.centerY) / (2.0 * RANGE), 0.0, 1.0);
    float nz = constrain(0.5 + (event.acceleration.z - s1.centerZ) / (2.0 * RANGE), 0.0, 1.0);

    s1.filtX = ALPHA * nx + (1 - ALPHA) * s1.filtX;
    s1.filtY = ALPHA * ny + (1 - ALPHA) * s1.filtY;
    s1.filtZ = ALPHA * nz + (1 - ALPHA) * s1.filtZ;

    if (now - lastTx >= TX_INT) {
      bool sent = false;
      if (abs(s1.filtX - s1.prevX) > THRESHOLD) {
        s1.prevX = s1.filtX;
        dataToSend.id = 1;
        dataToSend.value = s1.filtX;
        esp_now_send(receiverMAC, (uint8_t *)&dataToSend, sizeof(SensorPacket));
        sent = true;
        delayMicroseconds(500);
      }
      if (abs(s1.filtY - s1.prevY) > THRESHOLD) {
        s1.prevY = s1.filtY;
        dataToSend.id = 2;
        dataToSend.value = s1.filtY;
        esp_now_send(receiverMAC, (uint8_t *)&dataToSend, sizeof(SensorPacket));
        sent = true;
        delayMicroseconds(500);
      }
      if (abs(s1.filtZ - s1.prevZ) > THRESHOLD) {
        s1.prevZ = s1.filtZ;
        dataToSend.id = 3;
        dataToSend.value = s1.filtZ;
        esp_now_send(receiverMAC, (uint8_t *)&dataToSend, sizeof(SensorPacket));
        sent = true;
      }
      if (sent) { lastTx = now; }
    }
  }
}

Thanks for the above time signature screen shot!!

I have added another ESP32 sender with its own adxl345.

in max I received it as X2 Y2 Z2.

Do you recommend to make a separate file saver same as the first one I already got? (copy paste the whole system)

I don't mind saving it to the same file but I would likeif it is possible to separate that system into 3:

1 for first accel sensor X1 Y1 Z1

2 for moisture sensor M1

3 for second accel sensor X2 Y2 Z2

is that possible?

edit: OK it is make no sense to separate the data saved file into 3 seperated files, so basically my question is how to separate the system that show time with no active data within certain window time

The idea of that system is to know when there was time without active area, so that I can, in a negated way, know when the sensor was active

Sorry if I'm causing confusion. I'll try to explain myself again:

The current state is as follows:

I'm sending data from two different ESP32s, each with an ADXL345:
1: X1, Y1, Z1
2: X2, Y2, Z2

On the Receiver side, I also have a moisture sensor, M1.

In Max, I'm receiving all this data and saving it into a coll and a text file using the system you built.

How can I separate the system that shows a time window of X duration with no active data, so that sensor 1 has its own display (X1, Y1, Z1), sensor 2 has its own display (X2, Y2, Z2), and sensor 3 (M1) has its own as well?

I hope this makes it clearer/makes more sense.

Edit — from what I understand about how the system works, it records all the data together on the same line, and if there's no change in any of the values, it won't record a new line. But it's enough for just one of the values to change for a new line to be recorded. So, as the system is now, if one sensor is still for 2 minutes but the other changes every 5 seconds, I won't be able to separate the two sensors. So I might need to record each sensor to its own file in order to separate that "no active window" display system?

Following up on the RANGE/normalization discussion — right now RANGE is a fixed constant on the ESP32, baked into the value before it's sent and recorded, and the constrain(..., 0.0, 1.0) clips any value outside that range before it's ever recorded.

I'm worried that both of these together mean I permanently lose information: strong movements get clipped to exactly 1.0 (or 0.0) with no way to recover how strong they actually were, and if I later want to try a different RANGE, I'd need to re-flash and re-record from scratch.

I'm considering instead sending the raw acceleration delta (before dividing by RANGE, and without any clipping) and doing both the normalization and the clipping live in Max — so RANGE becomes an adjustable parameter I can tweak while listening back to already-recorded data, and the clip only affects the live sound/display path, not the recorded file itself.

Does that make sense as an approach? Any concerns with sending raw m/s² values over ESP-NOW instead of the current clipped 0-1 values — precision, range of the float, anything I'm missing?

At the beginning of this new code, I posted that it was meant for real time control and not for logging of any kind.

It gives you separated values, so that you can follow each sensor, and reduce data flow over ESP now and Serial port.

if you want to pack and log that list, nothing changes compared to old code.

but you can get info about each single sensor if you want when dumping the coll,

just route each of them to separated detector.

or only split accel 1, accel 2 and M1, or record 3 files, or 7 files ?

.................

you wanted constrain 0 – 1 there it is. if you want to remove it, then do it simple as that.

then in max you can see how to deal with the values.

I am not going to suggest anything again, because it is competely unknown what you want to do with the values, beside logging them.

you either measure absolute change to calibrated middle point, or change between 2 readings,

no matter in which direction.

that would create completely different effect as control.

You can also decide to send a list as you did before using set interval, and do all the rest in max.

remove threshold , remove constrain and simply send and send.

Is not efficient for battery life at all, but you can also use power supply.

Decide at what interval to send and adjust ADXL345_DATARATE and TX_INT

and in case of very fast update lift CPU to 160

on receiver side increase BAUD to 921600 and poll in max as fast as needed.

I actually thought that you want to use sensors in real time, not to record and playback.

If it is only playback, think about inactivity periods , if you spool playback at silent part, you will have no control change till new coll line triggers. Unless you implement a sort of event chasing.

At the beginning of this new code, I posted that it was meant for real time control and not for logging of any kind

I actually thought that you want to use sensors in real time, not to record and playback.

The playback and recorded system is for testing and seeing the data. After that period it will be indeed live and not playback

Unless you implement a sort of event chasing.

What does it means?

just route each of them to separated detector.

Could you please show how this can be done?

or only split accel 1, accel 2 and M1, or record 3 files, or 7 files ?

Do you think it is better method?

In that case I will need to duplicate the current system right? Making 4 different coll, one for each sensor