How to compress an hexadecimal number into a short string?

Projects Programming
35

232:
Because you have not initialized the array

uint8_t tagEPCBytes[50][12] = {};

thanks for the hint! :), Now I have nice zeros all over the array

0 0 0 0 0 0 0 0 0 0 0 0

232:
Definitely better initial approach, but then there will be "another problem" updating / clearing the array.
That may show up in next post as "new problem " soon.

if I make it a global variable, It will use 1350 Bytes (65%) from 2048 Bytes.
if I use it in the void loop(), It will use 750 Bytes (36%) from 2048 Bytes.

i'm gonna leave it in the loop, 65% is definitely too big.

With the following function I try to find duplicate entries in the array

int find(uint8_t *x[], uint8_t *y[][12])
{
    int i, j;

    for (i = 0; i < 3; i++) {
        for (j = 0; j < 12; j++) {
            if (x[j] != y[i][j]) break;
            if ( j == 11) {
                Serial.print("exists in row %d\n", i);
                return 0;
            }
        }
    }
    Serial.print("does not exists\n");
    return 1;
}

i get the following errors

no known conversion for argument 1 from 'const char [18]' to 'unsigned int'
cannot convert 'uint8_t* {aka unsigned char*}' to 'uint8_t** {aka unsigned char**}' for argument '1' to 'int find(uint8_t**, uint8_t* (*)[12])'

enclosed the full code

#include <SoftwareSerial.h> 
#include <stddef.h>

SoftwareSerial softSerial(2, 3); 

#include "SparkFun_UHF_RFID_Reader.h" 
RFID nano; 

#define BUZZER1 10

#define BUZZER2 9

boolean tagDetected; 
long lastSeen = 0; 
int counter = 0; 

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

  pinMode(BUZZER1, OUTPUT);
  pinMode(BUZZER2, OUTPUT);

  digitalWrite(BUZZER2, LOW); 

  while (!Serial); 

  if (setupNano(38400) == false) 
  {
    Serial.println(F("Das Modul hat nicht reagiert. Bitte überprüfen Sie die Anschlüsse."));
    while (1); 
  }

  nano.setRegion(REGION_NORTHAMERICA); 

  
  nano.setReadPower(2700); 
  

  nano.startReading(); 

  Serial.println("Scannprozess läuft!");

  lowBeep(); 
  tagDetected = false;  
}

void loop()
{
  byte myEPC[12]; 
  byte myEPClength;
  byte responseType = 0;
  
  uint8_t tagEPCBytes[50][12] = {};
  uint8_t singleTagEPCBytes[12] = {};


  if (nano.check() == true) 
  {
    byte responseType = nano.parseResponse(); 

    if (responseType == RESPONSE_IS_TAGFOUND)
    {
      long timeStamp = nano.getTagTimestamp(); 
      byte tagEPCByteCount = nano.getTagEPCBytes(); 

      Serial.print(F("RFID-Tag detektiert: "));
      Serial.println(counter); 


      
      Serial.print(F("Bin-Daten["));
      for (byte p = 0 ; p < tagEPCByteCount ; p++)
      {
        tagEPCBytes[counter][p] = ((uint8_t) nano.msg[31 + p]);
        singleTagEPCBytes [p] = ((uint8_t) nano.msg[31 + p]);
        
        if((p == tagEPCByteCount) && (counter > 0)) { 
          find (singleTagEPCBytes, tagEPCBytes); }
        
        Serial.print(nano.msg[31 + p]);
        if (p != 11) Serial.print(F(" "));
      }
      Serial.println(F("] "));

      if (tagDetected == false) 
      {
        tagDetected = true;
        
      }
      else if (millis() - lastSeen > 250) 
      {
        
      }
      lastSeen = millis();

      counter++;
    }
  }

  if (tagDetected == true && (millis() - lastSeen) > 1000)
  {
    Serial.println(F("Kein RFID-Tag gefunden..."));

    tagDetected = false;
    
  }

  
  if (Serial.available())
  {
    nano.stopReading(); 
    Serial.read(); 
    
    delay(1000);
    
    Serial.println("Array Ausgabe:\n");
    delay(333);
    int i, j;    
    for (i = 0; i < 50; i++) {
      for (j = 0; j < 12; j++) {
        Serial.print(tagEPCBytes[i][j]);
        Serial.print(" ");
        if (j == 11) {
          Serial.println(" ");
        }
      }
    }
    delay(333);
    Serial.println("Scannen angehalten. Drücken Sie die Taste, um fortzufahren.");

    while (!Serial.available());
    Serial.read(); 

    nano.startReading(); 
  }
}



boolean setupNano(long baudRate)
{
  nano.begin(softSerial); 

  

  
  
  softSerial.begin(baudRate); 
  while (!softSerial); 

  
  while (softSerial.available()) softSerial.read();

  nano.getVersion();

  if (nano.msg[0] == ERROR_WRONG_OPCODE_RESPONSE)
  {
    
    nano.stopReading();

    Serial.println(F("Modul liest kontinuierlich. Modul soll kontinuierlich lesen beenden...."));

    delay(1500);
  }
  else
  {
    
    softSerial.begin(115200); 

    nano.setBaud(baudRate); 

    softSerial.begin(baudRate); 
  }

  
  nano.getVersion();
  if (nano.msg[0] != ALL_GOOD) return (false); 

  
  nano.setTagProtocol(); 

  nano.setAntennaPort(); 

  return (true); 
}

void lowBeep()
{
  tone(BUZZER1, 130, 150); 
  
}

void highBeep()
{
  tone(BUZZER1, 2093, 150); 
  
}

int find(uint8_t *x[], uint8_t *y[][12])
{
    int i, j;

    for (i = 0; i < 3; i++) {
        for (j = 0; j < 12; j++) {
            if (x[j] != y[i][j]) break;
            if ( j == 11) {
                Serial.print("exists in row %d\n", i);
                return 0;
            }
        }
    }
    Serial.print("does not exists\n");
    return 1;
}

Here I try to putt all 12 bytes in the "singleTagEPCBytes" array and try to find them in the "tagEPCBytes" array.

singleTagEPCBytes [p] = ((uint8_t) nano.msg[31 + p]);
        
        if((p == tagEPCByteCount) && (counter > 0)) { 
          find (singleTagEPCBytes, tagEPCBytes); }

how can i correct the error?