ESP-NOW with blynk problem

In my project I use 1 esp32 to read 4 pzems data and receive control signal from another esp32, then send pzems data to another esp32 via esp-now communication, the other esp32 will receive pzems data and connect blynk to show those pzems data on blynk dashboard and also control relays by send control signal to esp32 with pzems.

now my problem is the esp32 with pzems showing pzems data on serial monitor but on the esp32 that receive data show pzems value = 0, it connected to blynk and I also can control relays on esp32 that with pzems on blynk dashboard, it just not receive any pzems data

this is the code I use:
(esp32 with pzems or sender)

#include <esp_now.h>
#include <WiFi.h>
#include <PZEM004Tv30.h>

#define PZEM_RX 16
#define PZEM_TX 17
#define PZEM_SERIAL Serial2
#define NUM_PZEMS 4

typedef struct relay_message {
  bool EDL_relay;
  bool PV1_relay;
  bool PV2_relay;
  bool Hybrid_relay;
} relay_message;

typedef struct ack_message {
  bool EDL_ack;
  bool PV1_ack;
  bool PV2_ack;
  bool Hybrid_ack;
} ack_message;

typedef struct struct_message {
  float voltage;
  float current;
  float power;
  float energy;
  float frequency;
  float pf;
} struct_message;

relay_message relayData;
ack_message ackData;
struct_message myData[NUM_PZEMS];

PZEM004Tv30 pzems[NUM_PZEMS];

uint8_t receiverAddress[] = { 0x**, 0x**, 0x**, 0x**, 0x**, 0x** };

#define EDL 26
#define PV1 27
#define PV2 32
#define Hybrid 33

void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int len) {
  memcpy(&relayData, data, sizeof(relayData));

  digitalWrite(EDL, relayData.EDL_relay ? HIGH : LOW);
  digitalWrite(PV1, relayData.PV1_relay ? HIGH : LOW);
  digitalWrite(PV2, relayData.PV2_relay ? HIGH : LOW);
  digitalWrite(Hybrid, relayData.Hybrid_relay ? HIGH : LOW);

  ackData.EDL_ack = relayData.EDL_relay;
  ackData.PV1_ack = relayData.PV1_relay;
  ackData.PV2_ack = relayData.PV2_relay;
  ackData.Hybrid_ack = relayData.Hybrid_relay;

  esp_err_t result = esp_now_send(receiverAddress, (uint8_t *)&ackData, sizeof(ackData));
  if (result == ESP_OK) {
    Serial.println("Acknowledgment sent successfully");
  } else {
    Serial.println("Error sending acknowledgment");
  }
}

void setup() {
  Serial.begin(115200);
  pinMode(EDL, OUTPUT);
  pinMode(PV1, OUTPUT);
  pinMode(PV2, OUTPUT);
  pinMode(Hybrid, OUTPUT);
  digitalWrite(EDL, LOW);
  digitalWrite(PV1, LOW);
  digitalWrite(PV2, LOW);
  digitalWrite(Hybrid, LOW);

  for (int i = 0; i < NUM_PZEMS; i++) {
    pzems[i] = PZEM004Tv30(PZEM_SERIAL, PZEM_RX, PZEM_TX, 0x01 + i);
  }

  WiFi.mode(WIFI_STA);
  WiFi.begin("ESP32S3-AP", "Sproject"); // Connect to receiver's AP

  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    Serial.print(".");
  }
  Serial.println("Connected to receiver's AP");

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

  esp_now_register_recv_cb(OnDataRecv);

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, receiverAddress, 6);
  peerInfo.channel = 11;
  peerInfo.encrypt = false;

  if (esp_now_add_peer(&peerInfo) != ESP_OK) {
    Serial.println("Error adding peer");
    return;
  }
}

void loop() {
  for (int i = 0; i < NUM_PZEMS; i++) {
    myData[i].voltage = pzems[i].voltage();
    myData[i].current = pzems[i].current();
    myData[i].power = pzems[i].power();
    myData[i].energy = pzems[i].energy();
    myData[i].frequency = pzems[i].frequency();
    myData[i].pf = pzems[i].pf();

    Serial.print("PZEM ");
    Serial.print(i + 1);
    Serial.println(":");
    Serial.print("Voltage: ");
    Serial.println(myData[i].voltage);
    Serial.print("Current: ");
    Serial.println(myData[i].current);
    Serial.print("Power: ");
    Serial.println(myData[i].power);
    Serial.print("Energy: ");
    Serial.println(myData[i].energy);
    Serial.print("Frequency: ");
    Serial.println(myData[i].frequency);
    Serial.print("Power Factor: ");
    Serial.println(myData[i].pf);
    Serial.println();
  }

  esp_err_t result = esp_now_send(receiverAddress, (uint8_t *)&myData, sizeof(myData));

  if (result != ESP_OK) {
    Serial.println("Error sending data via ESP-NOW");
  }

  delay(1000);
}

(Receiver esp32 receive pzems and connect blynk)

#define BLYNK_PRINT Serial
#define BLYNK_TEMPLATE_ID "****************"
#define BLYNK_TEMPLATE_NAME "*************"
#define BLYNK_AUTH_TOKEN "***********************"

#include <esp_now.h>
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>

#define NUM_PZEMS 4

uint8_t senderAddress[] = { 0x**, 0x**, 0x**, 0x**, 0x**, 0x** };
int i;

typedef struct struct_message {
  float voltage;
  float current;
  float power;
  float energy;
  float frequency;
  float pf;
} struct_message;

typedef struct relay_message {
  bool EDL_relay;
  bool PV1_relay;
  bool PV2_relay;
  bool Hybrid_relay;
} relay_message;

typedef struct ack_message {
  bool EDL_ack;
  bool PV1_ack;
  bool PV2_ack;
  bool Hybrid_ack;
} ack_message;

struct_message receivedData[NUM_PZEMS];
relay_message relayData;
ack_message ackData;
volatile bool ackReceived = false;

void sendControlSignal() {
  esp_err_t result;
  ackReceived = false;
  bool success = false;
  int retryCount = 0;

  while (!success && retryCount < 5) {  // Retry up to 5 times if acknowledgment not received
    result = esp_now_send(senderAddress, (uint8_t *)&relayData, sizeof(relayData));
    if (result == ESP_OK) {
      // Serial.println("Control signal sent successfully, waiting for acknowledgment...");
      unsigned long start = millis();
      while (!ackReceived && millis() - start < 1000) {
        delay(10);
      }
      if (ackReceived) {
        // Serial.println("Acknowledgment received");
        success = true;  // Set success flag if acknowledgment received
      } else {
        // Serial.println("Acknowledgment not received, retrying...");
        retryCount++;
      }
    } else {
      // Serial.println("Error sending control signal");
      retryCount++;
    }
    delay(1000);
  }

  if (!success) {
    // Serial.println("Failed to trigger relay after multiple attempts");
  }
}

void onDataReceived(const uint8_t *mac, const uint8_t *data, int len) {
  if (len == sizeof(receivedData)) {
    memcpy(&receivedData, data, sizeof(receivedData));
  }
}

void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
  Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
  ackReceived = (status == ESP_NOW_SEND_SUCCESS);
}

BLYNK_WRITE(V0) {
  int EDL_relay = param.asInt();
  relayData.EDL_relay = (EDL_relay == 1);
  sendControlSignal();
}

BLYNK_WRITE(V1) {
  int PV1_relay = param.asInt();
  relayData.PV1_relay = (PV1_relay == 1);
  sendControlSignal();
}

BLYNK_WRITE(V2) {
  int PV2_relay = param.asInt();
  relayData.PV2_relay = (PV2_relay == 1);
  sendControlSignal();
}

BLYNK_WRITE(V27) {
  int Hybrid_relay = param.asInt();
  relayData.Hybrid_relay = (Hybrid_relay == 1);
  sendControlSignal();
}

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

  WiFi.mode(WIFI_AP_STA);

  bool apSetup = WiFi.softAP("ESP32S3-AP", "Sproject", 11);

  if (apSetup) {
    Serial.println("AP setup successful.");
    Serial.print("AP IP address: ");
    Serial.println(WiFi.softAPIP());
  } else {
    Serial.println("AP setup failed.");
  }

  delay(1000);

  WiFi.begin("S-room-2.4G", "Sproject");

  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(100);
    Serial.print(".");
  }
  Serial.println("\nWiFi connected");
  Serial.print("Station IP address: ");
  Serial.println(WiFi.localIP());

  Blynk.begin(BLYNK_AUTH_TOKEN, "S-room-2.4G", "Sproject", "blynk.cloud", 8080);

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

  esp_now_peer_info_t peerInfo = {};
  memcpy(peerInfo.peer_addr, senderAddress, 6);
  peerInfo.channel = 11;
  peerInfo.encrypt = false;

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

  esp_now_register_send_cb(OnDataSent);
  esp_now_register_recv_cb(OnDataRecv);
}

void loop() {
  for (int i = 0; i < NUM_PZEMS; i++) {
    Serial.print("PZEM ");
    Serial.print(i + 1);
    Serial.println(":");
    Serial.print("Voltage: ");
    Serial.println(receivedData[i].voltage);
    Serial.print("Current: ");
    Serial.println(receivedData[i].current);
    Serial.print("Power: ");
    Serial.println(receivedData[i].power);
    Serial.print("Energy: ");
    Serial.println(receivedData[i].energy, 3);
    Serial.print("Frequency: ");
    Serial.println(receivedData[i].frequency, 1);
    Serial.print("Power Factor: ");
    Serial.println(receivedData[i].pf);
    Serial.println();
  }

  Blynk.run();
  delay(1000);
}

void OnDataRecv(const uint8_t *mac, const uint8_t *incomingData, int len) {
  memcpy(&receivedData, incomingData, sizeof(receivedData));
}