Arduino.ru

у вас в коде что-то незаметно вообще чтения меток - ни 4хбайтных, ни семи. Так не пойдет, тут на форуме за новичков код не пишут, только правят то. что уже написано.

Зачем-то только создано куча массивов размером пять(?) байт. Почему пять? - если раньше было 4, а теперь нужно семь? - тайна

Я не полный код вам выслал. 

byte ActualUID[5];                        //This will store the ID each time we read a new ID code

byte USER1[5]= {0xFE, 0x6D, 0x04, 0xA3} ; //Master ID code Change it for yor tag. First use the READ exampel and check your ID

byte USER2[5]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER2
byte USER3[5]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER3
byte USER4[5]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER4
byte USER5[5]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER5
byte USER6[5]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER6

продолжение кода: 

if(!normal_mode)
  {
    // Мы проверяем, есть ли новые карты
    if ( mfrc522.PICC_IsNewCardPresent()) 
          {  
        //Мы выбираем карту
              if ( mfrc522.PICC_ReadCardSerial()) 
              {
                    // Мы отправим ваш UID
                    
                    for (byte i = 0; i < mfrc522.uid.size; i++) {
                               
                            ActualUID[i]=mfrc522.uid.uidByte[i];          
                    } 

Пять сделано для 5 карт, которые могут валидировать. Проблема в том, что я не знаю как писать 7 байтную метку, чтобы она сопоставляла с программой. При сходимости, серво открывается. Еще раз повторяю не полностью написал код. Остальное неважно

вы не поняли, я не про число массивов спрашивал, а про число элементов в них.

Давайте начнем с азов - вы понимаете, что происходит вот в этой строке:

byte USER1[5]= {0xFE, 0x6D, 0x04, 0xA3} ;

сможете обьяснить?

Рахмет, я уже понял получается [] - количество допустимых байтов. ТАк?

Я не знаю, что значит "допустимых байтов" - и что такое недопустимые байты...

Цифра в квадратных скобках - это размер массива. Значит для хранения 4хбайтных ключей вам нужен массив байт из четырех элементов, а для Ультралайта - из семи.

Должен сказать. что если даже смысл числа в квадратных скобках вы знаете нетвердо - вам явно рано писать код для работы с РФИД. Ничего из этого не выйдет. Отложите на время ардуину и потратьте пару недель на чтение какой-нибудь методички по языку Си. Вы потом быстро эти недели отобьете...

модераторам - просьба перенести в песочницу.

Nuradil - прежде чем что-то отвечать - зайдите в Песочнице в заглавную тему и прочитайте хотя бы начальные сообщения МАКСИМАЛЬНО ВНИМАТЕЛЬНО.

b707, не хотел вас тревожить по пустякам, но вы реально помогаете. Есть еще один вопросик и все:

Функция в серво writemicroseconds отвечает за поворот сервопривода, она отличается от простого write тем, что позволяет поворачивать в стороне часовой или против

Вопрос: в коде написал writeMicroseconds(1000), но серво поворачивает не полностью(на 15-20 градусов), какие проблемы возможны?

нда, b707 как вы быстро про карты донесли, чел все понял моментально, теперь про серву... ржу :))

Ты бы помог лучше)

Поржем потом

а то :)

Я б и про серву ему разом все обьяснил - если б сам знал

write(градусы) пересчитывает значение градусов в микросекунды. А writeMicroseconds(микросекунды) напрямую активирует управляющий пин  на заданное время. Серва считает на сколько мкс был активен управляющий пин и, соотвественно, поворачивает качалку. Для SG90 0 градусов ~540мкс.

Огромное спасибо, b707. Красавчик

sadman41, ты уверен?? 

есть проблемы с writeMicroseconds(1000) - это команда же значение 1000 максимальный поворот против часовой стрелки. http://arduino.ru/Reference/Library/Servo/writeMicroseconds

ну почему ты первый абзац прочитал, а второй нет?

"Замечание: некоторые производители не придерживаются стандартных значение и такие приводы могут управляться значениями от 700 до 2300. Поэкспериментируйте со значениями, до момента пока привод не повернется и остановится в крайнем положение."

Есть аргументированные возражения? Спорьте с этим (Servo.h):
 

#define MIN_PULSE_WIDTH       544     // the shortest pulse sent to a servo  
#define MAX_PULSE_WIDTH      2400     // the longest pulse sent to a servo 
#define DEFAULT_PULSE_WIDTH  1500     // default pulse width when servo is attached

вот и помогай после этого :(

К сожалению топикстартер не привёл код целиком! Пришлось гуглить, чтобы найти его источник!

/* RFID door lock code example.
 * Visit the video: https://www.youtube.com/watch?v=X7hUSqS86DM
 * Visit webpage tutorial: http://www.ELECTRONOOBS.com/eng_arduino_tut26.php
 * 
 * Connections: http://www.ELECTRONOOBS.com/eng_arduino_tut26_sch1.php */

#include <SPI.h>
#include <MFRC522.h> 	//Downlaod the library: http://www.electronoobs.com/eng_arduino_MFRC522.php
#include <Servo.h> 

//LCD config
#include <Wire.h> 
#include <LiquidCrystal_I2C.h>	//Downlaod the library: http://www.electronoobs.com/eng_arduino_liq_crystal.php
LiquidCrystal_I2C lcd(0x3f,20,4);  //sometimes the adress is not 0x3f. Change to 0x27 if it dosn't work.


#define RST_PIN  9    //Pin 9 is for the RC522 reset
#define SS_PIN  10   //Pin 10 is the SS (SDA) of RC522 module
MFRC522 mfrc522(SS_PIN, RST_PIN); //Create anew RC522 object
Servo motor_1;


//Variables
boolean door_opened=false;
boolean first_read=false;
boolean normal_mode=true;
boolean countdown = false;
int timer=0;
int user_added=0;
int  add_ID_counter = 0;

//I/O
int buzzer_pin=7;
int outside_close = 4;      //pin for the button of the outside open
int inside_close = 6;       //pin for the button of the inside close
int inside_open = 5;        //pin for the button of the inside open


void setup() {
  SPI.begin();                 //Start a new SPI bus
  mfrc522.PCD_Init();          // Startt the MFRC522  
  motor_1.attach(3);           //Set digital pin D3 to be the PWM signal for the servo motor
  pinMode(buzzer_pin,OUTPUT);  //Set digital pin D7 to be the buzzer OUTPUT
  
  //Config of the i2c LCD screen
  lcd.init();
  lcd.backlight();
  lcd.setCursor(0,0);
  lcd.print("Place card here!");
  lcd.setCursor(0,1);
  lcd.print("                ");
  motor_1.writeMicroseconds(1000); //Put the servo in to the close position
}

byte ActualUID[4];                        //This will store the ID each time we read a new ID code

byte USER1[4]= {0x09, 0x92, 0x53, 0x28} ; //Master ID code Change it for yor tag. First use the READ exampel and check your ID

byte USER2[4]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER2
byte USER3[4]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER3
byte USER4[4]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER4
byte USER5[4]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER5



void loop() {

  if(digitalRead(outside_close))        //If the button is pressed, we close the door
  {
     door_opened=false;
     first_read=false;
     countdown = false;
     add_ID_counter = 0;
     motor_1.writeMicroseconds(1000); 
     lcd.setCursor(0,0);
     lcd.print("  Door  closed  ");
     lcd.setCursor(0,1);
     lcd.print("  from OUTSIDE  ");
     digitalWrite(buzzer_pin,HIGH);
     delay(300);
     digitalWrite(buzzer_pin,LOW);
     delay(4000);
     lcd.setCursor(0,0);
     lcd.print("Place card here!");
     lcd.setCursor(0,1);
     lcd.print("  DOOR  CLOSED  ");
  }


  if(digitalRead(inside_close))         //If the button is pressed, we close the door
  {
     door_opened=false;
     first_read=false;
     countdown = false;
     add_ID_counter = 0;
     motor_1.writeMicroseconds(1000); 
     lcd.setCursor(0,0);
     lcd.print("  Door  closed  ");
     lcd.setCursor(0,1);
     lcd.print("  from  INSIDE  ");
     digitalWrite(buzzer_pin,HIGH);
     delay(300);
     digitalWrite(buzzer_pin,LOW);
     delay(4000);
     lcd.setCursor(0,0);
     lcd.print("Place card here!");
     lcd.setCursor(0,1);
     lcd.print("  DOOR  CLOSED  ");
  }



  if(digitalRead(inside_open))        //If the button is pressed, we open the door
  {
     door_opened=true;
     first_read=false;
     countdown = false;
     add_ID_counter = 0;
     motor_1.writeMicroseconds(1500); 
     lcd.setCursor(0,0);
     lcd.print("   Door  open   ");
     lcd.setCursor(0,1);
     lcd.print("  from  INSIDE  ");
     digitalWrite(buzzer_pin,HIGH);
     delay(300);
     digitalWrite(buzzer_pin,LOW);
     delay(4000);
     lcd.setCursor(0,0);
     lcd.print("Place card here!");
     lcd.setCursor(0,1);
     lcd.print("  DOOR  OPENED  ");
  }

  
  if(normal_mode)
  {

    if(countdown)
    {
      if(add_ID_counter > 300)
      {
        countdown = false;
        first_read=false; 
        add_ID_counter = 0;
        lcd.setCursor(0,0);
        lcd.print("New ID  canceled");
        lcd.setCursor(0,1);
        lcd.print("                ");
        digitalWrite(buzzer_pin,HIGH);
        delay(1000);
        digitalWrite(buzzer_pin,LOW);
        delay(4000);
        lcd.setCursor(0,0);
        lcd.print("Place card here!");
        lcd.setCursor(0,1);
        lcd.print("                ");
      }

      if(add_ID_counter == 50)
      {
        lcd.setCursor(15,1);
        lcd.print("5");
        digitalWrite(buzzer_pin,HIGH);
        delay(100);
        digitalWrite(buzzer_pin,LOW);
      }

      if(add_ID_counter == 100)
      {
        lcd.setCursor(15,1);
        lcd.print("4");
        digitalWrite(buzzer_pin,HIGH);
        delay(100);
        digitalWrite(buzzer_pin,LOW);
      }

      if(add_ID_counter == 150)
      {
        lcd.setCursor(15,1);
        lcd.print("3");
        digitalWrite(buzzer_pin,HIGH);
        delay(100);
        digitalWrite(buzzer_pin,LOW);
      }

      if(add_ID_counter == 200)
      {
        lcd.setCursor(15,1);
        lcd.print("2");
        digitalWrite(buzzer_pin,HIGH);
        delay(100);
        digitalWrite(buzzer_pin,LOW);
      }

      if(add_ID_counter == 250)
      {
        lcd.setCursor(15,1);
        lcd.print("1");
        digitalWrite(buzzer_pin,HIGH);
        delay(100);
        digitalWrite(buzzer_pin,LOW);
      }

      
      add_ID_counter = add_ID_counter+1;
      delay(10);
    }


    
    // Check if there are any new ID card in front of the sensor
    if ( mfrc522.PICC_IsNewCardPresent()) 
          {  
        //Select the found card
              if ( mfrc522.PICC_ReadCardSerial()) 
              {
                    // We store the read ID into 4 bytes with a for loop                  
                    for (byte i = 0; i < mfrc522.uid.size; i++) {
                      ActualUID[i]=mfrc522.uid.uidByte[i];          
                    } 
                                    
                    //Compare the UID and check if the new iD is on the user listz
  
                    
                             if(first_read)
                            {
                                    if(compareArray(ActualUID,USER1))
                                    { 
                                        countdown=false;
                                        add_ID_counter = 0;
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);
                                        normal_mode=false;
                                        lcd.setCursor(0,0);
                                        lcd.print("Place New ID in:");
                                        lcd.setCursor(0,1);
                                        lcd.print("       3        ");
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(100);
                                        digitalWrite(buzzer_pin,LOW);                                        
                                        delay(1000);
                                        lcd.setCursor(0,1);
                                        lcd.print("       2        ");
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(100);
                                        digitalWrite(buzzer_pin,LOW);
                                        delay(1000);
                                        lcd.setCursor(0,1);
                                        lcd.print("       1       ");
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(100);
                                        digitalWrite(buzzer_pin,LOW);
                                        delay(1000);
                                        lcd.setCursor(0,1);
                                        lcd.print("      NOW!      ");
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(500);
                                        digitalWrite(buzzer_pin,LOW);
                                       
                                        
                                    }
                                    else
                                    {
                                      first_read=false;                  
                                     
                                    }
                            }
                            
                            if(!first_read)
                            {
                                    if(compareArray(ActualUID,USER1))
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access granted ");
                                        lcd.setCursor(0,1);
                                        lcd.print("  MASTER  USER  ");
                                        digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1500); 
                                        door_opened=true;
                                        first_read=true;
                                        countdown=true;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Put  MASTER card");
                                        lcd.setCursor(0,1);
                                        lcd.print("for new ID     6");
                                        digitalWrite(buzzer_pin,HIGH);
                                        delay(100);
                                        digitalWrite(buzzer_pin,LOW);
                                        
                                    }
                                    else if(compareArray(ActualUID,USER2))
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access granted ");
                                        lcd.setCursor(0,1);
                                        lcd.print("     USER 2     ");
                                        digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1500); 
                                        door_opened=true;
                                        first_read=true;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Last use: USER2");
                                        lcd.setCursor(0,1);
                                        lcd.print("  Door OPENED  ");
                                    }
                                    else if(compareArray(ActualUID,USER3))
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access granted ");
                                        lcd.setCursor(0,1);
                                        lcd.print("     USER 3     ");
                                        digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1500); 
                                        door_opened=true;
                                        first_read=true;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Last use: USER3");
                                        lcd.setCursor(0,1);
                                        lcd.print("  Door OPENED  ");
                                    }
                                    else if(compareArray(ActualUID,USER4))
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access granted ");
                                        lcd.setCursor(0,1);
                                        lcd.print("     USER 4     ");
                                        digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1500); 
                                        door_opened=true;
                                        first_read=true;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Last use: USER4");
                                        lcd.setCursor(0,1);
                                        lcd.print("  Door OPENED  ");
                                    }
                                    else if(compareArray(ActualUID,USER5))
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access granted ");
                                        lcd.setCursor(0,1);
                                        lcd.print("     USER 5     ");
                                        digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(300);
                                        digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1500); 
                                        door_opened=true;
                                        first_read=true;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Last use: USER5");
                                        lcd.setCursor(0,1);
                                        lcd.print("  Door OPENED  ");
                                    }
                                    else
                                    {
                                        lcd.setCursor(0,0);
                                        lcd.print(" Access  denied ");
                                        lcd.setCursor(0,1);
                                        lcd.print("   UNKNOWN ID   ");
                                        analogWrite(buzzer_pin,200);    //use analogWrite(buzzer_pin,200); for non active buzzer
                                        delay(1500);
                                        analogWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                                        motor_1.writeMicroseconds(1000); 
                                        door_opened=false;
                                        first_read=false;
                                        delay(3000);
                                        lcd.setCursor(0,0);
                                        lcd.print("Place card here!");
                                        lcd.setCursor(0,1);
                                        lcd.print("  Door CLOSED  ");
                                    }
                            }
                          
                            
                            
                            // Terminamos la lectura de la tarjeta tarjeta  actual
                            mfrc522.PICC_HaltA();
  
                                            
  
  
                            
              }
        
    }
  }//end  normal mode












  if(!normal_mode)
  {
    // Revisamos si hay nuevas tarjetas  presentes
    if ( mfrc522.PICC_IsNewCardPresent()) 
          {  
        //Seleccionamos una tarjeta
              if ( mfrc522.PICC_ReadCardSerial()) 
              {
                    // Enviamos serialemente su UID
                    
                    for (byte i = 0; i < mfrc522.uid.size; i++) {
                               
                            ActualUID[i]=mfrc522.uid.uidByte[i];          
                    } 
                                    
                    //Compare the read ID and the stored USERS
                    if(user_added==4)
                    {
                      lcd.setCursor(0,0);
                      lcd.print("  User list is  ");
                      lcd.setCursor(0,1);
                      lcd.print("      FULL      "); 
                      digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                      delay(3000);
                      digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer                     
                      lcd.setCursor(0,0);
                      lcd.print("Place card here!");
                      lcd.setCursor(0,1);
                      lcd.print("                ");
                    } 
                    
                    if(user_added==3)
                    {
                      USER5[0] = ActualUID[0];
                      USER5[1] = ActualUID[1];
                      USER5[2] = ActualUID[2];
                      USER5[3] = ActualUID[3];  
                      user_added = user_added+1;
                      lcd.setCursor(0,0);
                      lcd.print("New user stored ");
                      lcd.setCursor(0,1);
                      lcd.print("   as  USER 5   ");
                      digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                      delay(300);
                      digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                      delay(1000);
                      normal_mode=true;
                      first_read=false;
                      delay(3000);
                      lcd.setCursor(0,0);
                      lcd.print("Place card here!");
                      lcd.setCursor(0,1);
                      lcd.print("                ");
                    } 
                    
                    if(user_added==2)
                    {
                      USER4[0] = ActualUID[0];
                      USER4[1] = ActualUID[1];
                      USER4[2] = ActualUID[2];
                      USER4[3] = ActualUID[3];  
                      user_added = user_added+1;
                      lcd.setCursor(0,0);
                      lcd.print("New user stored ");
                      lcd.setCursor(0,1);
                      lcd.print("   as  USER 4   "); 
                      digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                      delay(300);
                      digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                      delay(1000);
                      normal_mode=true;
                      first_read=false;
                      delay(3000);
                      lcd.setCursor(0,0);
                      lcd.print("Place card here!");
                      lcd.setCursor(0,1);
                      lcd.print("                ");
                    } 
                    
                    if(user_added==1)
                    {
                      USER3[0] = ActualUID[0];
                      USER3[1] = ActualUID[1];
                      USER3[2] = ActualUID[2];
                      USER3[3] = ActualUID[3];  
                      user_added = user_added+1;
                      lcd.setCursor(0,0);
                      lcd.print("New user stored ");
                      lcd.setCursor(0,1);
                      lcd.print("   as  USER 3   "); 
                      digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                      delay(300);
                      digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                      delay(1000);
                      normal_mode=true;
                      first_read=false;
                      delay(3000);
                      lcd.setCursor(0,0);
                      lcd.print("Place card here!");
                      lcd.setCursor(0,1);
                      lcd.print("                ");
                    } 
                    
                    if(user_added==0)
                    {
                      USER2[0] = ActualUID[0];
                      USER2[1] = ActualUID[1];
                      USER2[2] = ActualUID[2];
                      USER2[3] = ActualUID[3];  
                      user_added = user_added+1;
                      lcd.setCursor(0,0);
                      lcd.print("New user stored ");
                      lcd.setCursor(0,1);
                      lcd.print("   as  USER 2   ");
                      digitalWrite(buzzer_pin,HIGH);    //use analogWrite(buzzer_pin,200); for non active buzzer
                      delay(300);
                      digitalWrite(buzzer_pin,LOW);    //use analog write for non active buzzer
                      delay(1000);
                      normal_mode=true;
                      first_read=false;
                      delay(3000);
                      lcd.setCursor(0,0);
                      lcd.print("Place card here!");
                      lcd.setCursor(0,1);
                      lcd.print("                ");
                    }                
                    
              }
        
    }
  }//end  ID add mode
  
}

//Compare the 4 bytes of the users and the received ID
 boolean compareArray(byte array1[],byte array2[])
{
  if(array1[0] != array2[0])return(false);
  if(array1[1] != array2[1])return(false);
  if(array1[2] != array2[2])return(false);
  if(array1[3] != array2[3])return(false);
  return(true);
}

Там одна карта используется как управляющая, а остальные - простые! 
Интересно, что для сравнения используется только 4-ре байта карты, а не 7! То есть сравнивается не весь идентификатор, а только его часть, если я правильно понял

Вот функция сравнения
 

//Compare the 4 bytes of the users and the received ID
 boolean compareArray(byte array1[],byte array2[])
{
  if(array1[0] != array2[0])return(false);
  if(array1[1] != array2[1])return(false);
  if(array1[2] != array2[2])return(false);
  if(array1[3] != array2[3])return(false);
  return(true);
}

Насколько я понял, здесь идет сравнение массивов побайтно, и только если всё четыре байта совпадут, то она возвратит TRUE!

Вопрос только в том, какие по счету байты сравниваются? 1,2,3,4 ? Верно? Справа налево? Или наоборот?
Я имею в виду, как их считывает эта функция?
 

if ( mfrc522.PICC_ReadCardSerial()) 
              {
                    // Enviamos serialemente su UID
                    
                    for (byte i = 0; i < mfrc522.uid.size; i++) {
                               
                            ActualUID[i]=mfrc522.uid.uidByte[i];          
                    } 

просто этот код - для карт Мифаре Классик, а в них UID  4 байта

Я думаю, что если правильно вписать сюда байты
 

byte USER2[4]= {0x00, 0x00, 0x00, 0x00} ; //Empty ID of USER2

или в аналогичный массив, то оно будет работать! 

Если например у меня UID 35 D3 AF 51 E5 29 70 мне достаточно просто подставить первых 4-ре байта? Я только не понимаю, какие вписывать! младшие?  (то есть 51 E5 29 70) или старшие? (35 D3 AF 51).

Если ли какой-то способ узнать, от какого байта начинается отсчет?

по хорошему, если у вас UID из 7 байт. то и массив надо сделать на 7 байт и вписать в него все

Так дело в том, что если оставить 4 байта, то подойдут  те и другие карты, а вот, если увеличить до 7, то те, что с менньшим количеством байт уже использовать не получится!

Кстати в заголовочном файле библиотеки, там вроде бы под UID выделяется 10 байт. Вот структура
 

	// A struct used for passing the UID of a PICC.
	typedef struct {
		byte		size;			// Number of bytes in the UID. 4, 7 or 10.
		byte		uidByte[10];
		byte		sak;			// The SAK (Select acknowledge) byte returned from the PICC after successful selection.
	} Uid;

size переменная для размера массива? а  uidByte[10]; показывает сколько элементов в нем иожет быть максимум. Верно?

А вы распознавайте тип карты - и те, у которых 4 байта - сравнивайте с 4 байтами, а те у которых 7 - с семью. Иначе вы сознательно снижаете взломостойкость своей программы.

Функция для проверки типа карты в библиотеке есть, ищите.

Я ещё даже толком не разобрался с функцией чтения. Не могу понять, почему вместо байт вылезают какие-то крякозябрики? Знаки вопроса, скобки и т.д. Скетч простейший:

#include <SPI.h>
#include <MFRC522.h>
#define RST_PIN  9    //Pin 9 is for the RC522 reset
#define SS_PIN  10   //Pin 10 is the SS (SDA) of RC522 module
MFRC522 mfrc522(SS_PIN, RST_PIN); //Create anew RC522 object


byte ActualUID[7];
//byte USER1[4]= {0x09, 0x92, 0x53, 0x28} ;                       

void setup() {
 Serial.begin(9600);
 SPI.begin();                 //Start a new SPI bus
 mfrc522.PCD_Init();          // Startt the MFRC522  
}

void loop() {
  // Look for new cards
  if ( ! mfrc522.PICC_IsNewCardPresent()) {
    return; }
 

  // Select one of the cards
  if ( ! mfrc522.PICC_ReadCardSerial()) {
  return;}
      else{   
       for (byte i = 0; i < mfrc522.uid.size; i++) {
                               
                 ActualUID[i] = mfrc522.uid.uidByte[i];          
                    } 
        
 }
 Serial.print(F("Readed data: "));
  //Dump a byte array to Serial
  for (byte i = 0; i < 7; i++) {
    Serial.write(ActualUID[i]);
  }
  Serial.println();
  
  mfrc522.PICC_HaltA();
}

Наверно вывод просто идет не в том формате! Подскажите пожалуйста, мне нужно всего лишь как-то изменить эту строку
 

Serial.write(ActualUID[i]);

или нет?

все верно - ошибка (если можно так сказать) была в ней! Нужно было использовать print, а не write! То есть написать так

Serial.print(ActualUID[i]);

теперь выводяться цифры номера, а не какие-то кракозябрики!
У меня остался только вопрос, зачем там в этой строчке

Serial.print(F("Readed data: "));

буква F перед скобками? Подскажите пожалуйста, кто знает!

1000 это обычно нулевое положение ПРАВИЛЬНОЙ СЕРВЫ, 2000 - конечное
Тут и к бабке не ходи у вас "неправильные пчёлы и неправильный мёд"

Serial.print(ActualUID[i]);

Serial.print(F("Readed data: "));

экономит память

подозреваю, что это сокращение от FLASH, то есть записать эту строку не в оперативку, а во флеш! Верно?

Со словом "флеш" угадали, а со словом "записать" - нет.

Я имею в виду, что это команда для компилятора записать эту строку во флеш память! Это строка ведь константа? Точнее массив констант типа CHAR? Верно? Тогда зачем тратить на неё оперативку?

Всё и так будет записано в progmem. Вопрос только в том - будет ли данная строка перегружаться в RAM на старте или не будет. F() - это такая ардуино-магия, которая придает правильные атрибуты строке и помогает print() найти ее (строку) в progmem space.

кстати я просмотрел скетч и не обнаружил там вообще никакой записи в память (для хранения)! То есть получается, что карточки записанные мастер картой будут работать только до тех пор, пока устройство включено! А дальше оно о них просто забудет. Верно?
Посмотрите
 

if(user_added==0)
                    {
                      USER2[0] = ActualUID[0];
                      USER2[1] = ActualUID[1];
                      USER2[2] = ActualUID[2];
                      USER2[3] = ActualUID[3];  
                      user_added = user_added+1;
                      lcd.setCursor(0,0);
                      lcd.print("New user stored ");
                 ......
                    }

а по идее должно быть что-то вроде EEPROM.put(eeAddress, USER2[]); и чтения EEPROM.get(eeAddress, USER2[]);
Но тут возникает ещё вопрос, как записывать, чтобы значение eeAddress тоже сохранялось после откл. питания!
Наверно под него нужно выделить 1 или 2 байта и обновлять после каждой записи? То есть добавили массив в память и 
 

eeAddress = eeAddress + sizeof(USER2) 
EEPROM.update(address, eeAddress);

Или как-то по другому?