After Arduino Uno sleep mode SLEEP_MODE_PWR_DOWN serial data is read incorrect

[DziugasMolis]

Hello,

I am trying to make a cat feeder for my cats. Everything works just fine without implementing sleep mode... I tried implementing sleep mode to save my electric bill and batteries... But unfortunately I can not find a way to do it. Until the first sleep reader is working fine, then it stops working. Even if it reads some kind of id, value of it is incorrect. I have moved serial reading part to loop() method. What I am doing wrong or what can I try to make it work... ? I do not have any electrical engineering background so any help would be very appreciated.

Here are some serial logs:
3:43:16.129 -> Rfid13Ar�ե������k�going to���eep... 23:43:34.066 -> Arduino���ke up! 23:43:34.066 -> Arduino���ke up! 23:43:34.066 -> Arduino���ke up! 23:43:34.066 -> Arduino���ke up! 23:43:35.811 -> Arduino���ke up! 23:43:35.811 -> Arduino woke up! 23:43:35.843 -> Arduino woke up! 23:43:35.843 -> Arduino woke up! 23:43:35.843 -> Arduino woke up! 23:43:35.843 -> Working 23:43:35.843 -> Rfid134_Error_None 23:43:35.843 -> Rfid134_Error_PacketEndCodeMissmatch 23:43:35.843 -> Rfid134_Error_Packe� ���cksum 23:43:37.718 -> Rfid����_Error_PacketChecksumInvert 23:43:37.752 -> 83821369977 23:43:37.752 -> Arduino woke up! 23:43:37.752 -> Arduino woke up! 23:43:37.752 -> Working 23:43:37.752 -> Rfid134_Error_None 23:43:37.752 -> Rfid134_Error_PacketEndCodeMissmatch 23:43:37.752 -> Rfid134_Erro���acketChecksum �He�id134_Error_Pac����ChecksumInvert 23:43:39.538 -> 17840194 23:43:39.580 -> Arduino woke up! 23:43:39.580 -> Arduino woke up! 23:43:39.580 -> Arduino woke up! 23:43:39.580 -> Working 23:43:39.580 -> Rfid134_Error_None 23:43:39.580 -> Rfid134_Error_PacketEndCodeMissmatch 23:43:39.580 -> Rfid134_�Q.�or_PacketChecks�W�� 23:43:41.161 -> Rfid134_Error_���ketChecksumInvert 23:43:41.161 -> 69688 23:43:41.206 -> Arduino woke up! 23:43:41.206 -> Arduino woke up! 23:43:41.206 -> Arduino woke up! 23:43:41.206 -> Working 23:43:41.206 -> Rfid134_Error_None 23:43:41.206 -> Rfid134_Error_PacketEndCodeMissmatch 23:43:41.206 -> Rfid1�&��Error_PacketChe����um 23:43:42.920 -> Rfid134_Err�K}�PacketChecksumI�˕�rt 23:43:42.920 -> 17

Code:

#include <avr/sleep.h>
#include <avr/power.h>
#include <SoftwareSerial.h>

// Define RX and TX pins for SoftwareSerial (optional)
const int rxPin = 10;
const int txPin = 11;


SoftwareSerial mySerial(rxPin, txPin);

enum Rfid134_Error {
  Rfid134_Error_None,

  // from library
  Rfid134_Error_PacketSize = 0x81,
  Rfid134_Error_PacketEndCodeMissmatch,
  Rfid134_Error_PacketChecksum,
  Rfid134_Error_PacketChecksumInvert
};

struct Rfid134Reading {
  uint16_t country;
  uint64_t id;
  bool isData;
  bool isAnimal;
  uint16_t reserved0;
  uint32_t reserved1;
};

enum DfMp3_Packet {
  Rfid134_Packet_StartCode = 0,
  Rfid134_Packet_Id = 1,
  Rfid134_Packet_Country = 11,
  Rfid134_Packet_DataFlag = 15,
  Rfid134_Packet_AnimalFlag = 16,
  Rfid134_Packet_Reserved0 = 17,
  Rfid134_Packet_Reserved1 = 21,
  Rfid134_Packet_CheckSum = 27,
  Rfid134_Packet_CheckSumInvert = 28,
  Rfid134_Packet_EndCode = 29,
  Rfid134_Packet_SIZE = 30
};

uint64_t HexLsbAsciiToUint64(char* text, uint8_t textSize) {
  uint64_t value = 0;
  uint8_t i = textSize;
  do {
    i--;

    uint8_t digit = text[i];
    if (digit >= 'A') {
      digit = digit - 'A' + 10;
    } else {
      digit = digit - '0';
    }
    value = (value << 4) + digit;
  } while (i != 0);

  return value;
};

void setup() {
  // Initialize hardware serial communication
  Serial.begin(115200);

  // Initialize software serial communication (optional)
  mySerial.begin(9600);
  mySerial.setTimeout(1000);
  while (!mySerial) {
    ;  // wait for serial port to connect. Needed for Leonardo only
  }

  Serial.println("Arduino is going to sleep...");

  // Set up the sleep mode
  set_sleep_mode(SLEEP_MODE_PWR_SAVE);  // Choose appropriate sleep mode

  // Enable sleep mode
  sleep_enable();

  // Attach the interrupt to wake up the Arduino upon receiving serial data
  attachInterrupt(digitalPinToInterrupt(rxPin), wakeUp, LOW);
}

void loop() {
  // Put the Arduino to sleep
  sleep_mode();  // The program will continue from here after waking up

  // Disable sleep mode after waking up
  sleep_disable();

  // Detach the interrupt
  detachInterrupt(digitalPinToInterrupt(rxPin));

  // Perform tasks after waking up
  Serial.println("Arduino woke up!");

  while (mySerial.available() >= Rfid134_Packet_SIZE) {
    Serial.println("Working");
    char packet[Rfid134_Packet_SIZE];

    packet[Rfid134_Packet_StartCode] = mySerial.read();

    //check for the first byte being the packet start code
    if (packet[Rfid134_Packet_StartCode] != 0x02) {
      Serial.println("Rfid134_Error_None");
    }

    uint8_t read;

    read = mySerial.readBytes(&(packet[Rfid134_Packet_Id]), Rfid134_Packet_SIZE - 1);

    if (read != Rfid134_Packet_SIZE - 1) {
      Serial.println("Rfid134_Error_PacketSize");
    }

    if (packet[Rfid134_Packet_EndCode] != 0x03 && packet[Rfid134_Packet_EndCode] != 0x07) {
      Serial.println("Rfid134_Error_PacketEndCodeMissmatch");
    }

    // calculate checksum
    uint8_t checksum = 0;
    for (uint8_t i = Rfid134_Packet_Id; i < Rfid134_Packet_CheckSum; i++) {
      checksum = checksum ^ packet[i];
    }

    // test checksum
    if (checksum != packet[Rfid134_Packet_CheckSum]) {
      Serial.println("Rfid134_Error_PacketChecksum");
    }

    if (static_cast<uint8_t>(~checksum) != static_cast<uint8_t>(packet[Rfid134_Packet_CheckSumInvert])) {
      Serial.println("Rfid134_Error_PacketChecksumInvert");
    }

    Rfid134Reading reading;

    // convert packet into the reading struct
    reading.id = HexLsbAsciiToUint64(&(packet[Rfid134_Packet_Id]), Rfid134_Packet_Country - Rfid134_Packet_Id);
    reading.country = HexLsbAsciiToUint64(&(packet[Rfid134_Packet_Country]), Rfid134_Packet_DataFlag - Rfid134_Packet_Country);
    reading.isData = packet[Rfid134_Packet_DataFlag] == '1';
    reading.isAnimal = packet[Rfid134_Packet_AnimalFlag] == '1';
    reading.reserved0 = HexLsbAsciiToUint64(&(packet[Rfid134_Packet_Reserved0]), Rfid134_Packet_Reserved1 - Rfid134_Packet_Reserved0);
    reading.reserved1 = HexLsbAsciiToUint64(&(packet[Rfid134_Packet_Reserved1]), Rfid134_Packet_CheckSum - Rfid134_Packet_Reserved1);
    print_uint64_t(reading.id);
  }

  // Prepare to sleep again by enabling sleep mode and attaching the interrupt
  sleep_enable();
  attachInterrupt(digitalPinToInterrupt(rxPin), wakeUp, LOW);
}

// Interrupt service routine to wake up the Arduino
void wakeUp() {
}


void print_uint64_t(uint64_t num) {

  char rev[128]; 
  char *p = rev+1;

  while (num > 0) {
    *p++ = '0' + ( num % 10);
    num/= 10;
  }
  p--;
  /*Print the number which is now in reverse*/
  while (p > rev) {
    Serial.print(*p--);
  }
  Serial.println();
}

[Makuna]

Software Serial probably already has a ISR attached to the pin and you just overwrote it. Arduino doesn't have cascading ISR, so you have to do it yourself, which problematic at best. When you go to register, first grab the ISR that is already present and store it, in your ISR, after you do your stuff, then call the stored method.

[DziugasMolis]

Would be nice if you could give a link explaining what ISR means 😄 I am software engineer so its a new thing for me, I do not have all the basics.

So as I understood you suggest using default rx,tx pins?

[DziugasMolis]

So I read more about what you said. These options I have in mind:

• After serial wake up go to sleep after some amount of seconds
• Before sleep flush serial

I have a question about storing ISR, do you have an example for it? I have basically no C++ background is a lot of thing are confusing when coming from Java background.

[Chrischi-]

I don't want to interrupt your discussion, but have you already asked ChatGPT about the problem? The AI provides quite good approaches and examples.

[DziugasMolis]

Help is very appreciated! I tried asking it: "arduino uno example sleep mode with serial wake up", "how to read all serial data on wake up".

Do you have a suggestion?

[Chrischi-]

„ISR example arduino ide“

[DziugasMolis]

finally chatgpt managed to generate a working example 😄 thanks for suggestion

#include <avr/sleep.h>
#include <avr/interrupt.h>

volatile char serialBuffer[64];
volatile uint8_t bufferIndex = 0;

void setup() {
  // Initialize serial communication at 9600 baud
  Serial.begin(9600);

  // Set up pin change interrupt on pin 0 (RX)
  PCICR |= (1 << PCIE0); // Enable Pin Change Interrupt for PCINT0 group
  PCMSK0 |= (1 << PCINT8); // Enable interrupt for pin 8 (RX pin)

  // Enable global interrupts
  sei();

  // Set up sleep mode
  set_sleep_mode(SLEEP_MODE_IDLE); // Choose idle mode to keep USART running
}

ISR(PCINT0_vect) {
  // No action needed here, ISR just wakes up the CPU
}

void loop() {
  // Check if serial data is available
  while (Serial.available() > 0) {
    // Read the received byte
    char receivedByte = Serial.read();
    
    // Store the byte in the buffer if there's space
    if (bufferIndex < sizeof(serialBuffer) - 1) {
      serialBuffer[bufferIndex++] = receivedByte;
      serialBuffer[bufferIndex] = '\0'; // Null-terminate the string
    }
  }

  // Process the received data if any
  if (bufferIndex > 0) {
    // Print the buffer content
    Serial.println((char*)serialBuffer);

    // Reset the buffer index
    bufferIndex = 0;
  }

  // Put the microcontroller to sleep
  sleep_mode();

  // The microcontroller will continue here after waking up from sleep
  // Add a small delay to avoid flooding the Serial monitor
  delay(100);
}

[DziugasMolis]

So I was happy too early, after further investigations even though we have method call for sleep mode but sleep mode it is SLEEP_MODE_IDLE, so loop() method is working and it does not go to sleep. After trying a real sleep mode it did not work.. 😄 So I am again at the start.

[Makuna]

Another hardware solution, jumper the RX pin to another available pin at the same time, and attach your ISR (Interrupt Service Routine) to that pin so you are not sharing the config on the pin itself.