wederom een vraag om assistentie.

[bossie Profiel Privébericht]

Ik was op zoek op het net om een ​​Arduino oplossing voor een deur project te vinden.
Ik vond deze hardware- en software-oplossing en ik wil een kleine aanpassingen maken.



Ik ben me bewust van het feit dat er een fout zit in het schema
de rode draad van het Serial LCDscherm moet worden verbonden met de rode-rail van de breadbord.

De ino bestand wordt toegevoegd als een attachement.

De oplossing doet waar hij voor gemaakt is.
Maar er is een groot nadeel van de gescande en toegevoegde kaarten worden bewaard in memory en na een powerdip of shutdown zijn er geen geldige kaarten meer.

Ik wil dit gebruiken als aan acces-control systeem voor een werkplaats en ca. 14 personen (of kaarten) moet een geldige toegang te hebben.
De procedure is:
Kaart toevoegen:
Scan de mastercard en binnen een gezette tijd scan een willekeurige kaart.
De laatste zal als valide kaart in het geheugen staan.
Kaart verwijderen:
Scan de mastercard en daarna de te verwijderen kaart.
Deze zal dan 'vergeten' worden.

De mastercard staat hardcoded in de source, en ik wil de toegevoegde kaarten op te slaan in een soort van permanente geheugen, bijv. een SD-kaart.

Voor dat doel heb ik dit SDcard shield gekocht.


[U] Logging Recorder Data Logger Module Shield voor Arduino UNO SD Card H12 [/ u]

Maar het shield gebruikt MISO MOSI SCK en CS
En MISO MOSI ans SCK worden al gebruikt door de RC522 RFID schild.

Kan iemand mij vertellen hoe ik moet dit 'probleem' aan te pakken
Voor zowel de hardware als software-oplossing?

Met vriendelijke groet Piet.

[nicoverduin Profiel PrivéberichtWebsite]

Beide kaarten gebruiken SPI. Om onderscheid te maken tussen SPI devices heb je de Card Select lijn (CS). Die moet je opgeven in de sketch bij de definitie.
En eh.... weinig attachment.

[shooter Profiel Privébericht]

Card select lijn, kun je zien als device select, als je de ene hoog maakt dan is de SD kaart actief en als je de CS van de rfid hoog maakt dan is je rc522 actief.

[bossie Profiel Privébericht]

Beide kaarten gebruiken SPI. Om onderscheid te maken tussen SPI devices heb je de Card Select lijn (CS). Die moet je opgeven in de sketch bij de definitie.
En eh.... weinig attachment.

Duidelijk Nico en Paul.
Is het misschien verstandig oom als opslag de EEPROM te gebruiken?

Het lukt me niet om een .ino te attachen.
Dus dan maar de code in de tekst.
cpp code

#include <SPI.h>
#include <Wire.h>
#include <MFRC522.h>
#include <LiquidCrystal_I2C.h>

#define RST_PIN 9
#define SS_PIN  10

#define STATE_STARTUP       0
#define STATE_STARTING      1
#define STATE_WAITING       2
#define STATE_SCAN_INVALID  3
#define STATE_SCAN_VALID    4
#define STATE_SCAN_MASTER   5
#define STATE_ADDED_CARD    6
#define STATE_REMOVED_CARD  7

#define REDPIN 6
#define GREENPIN 7

const int cardArrSize = 10;
const int cardSize    = 4;
byte cardArr[cardArrSize][cardSize];
byte masterCard[cardSize] = {86,187,140,117};
byte readCard[cardSize];
byte cardsStored = 0;

// Create MFRC522 instance
MFRC522 mfrc522(SS_PIN, RST_PIN);
// Set the LCD I2C address
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

byte currentState = STATE_STARTUP;
unsigned long LastStateChangeTime;
unsigned long StateWaitTime;

//------------------------------------------------------------------------------------
int readCardState()
{
  int index;

  Serial.print("Card Data - ");
  for(index = 0; index < 4; index++)
  {
    readCard[index] = mfrc522.uid.uidByte[index];

    
    Serial.print(readCard[index]);
    if (index < 3)
    {
      Serial.print(",");
    }
  }
  Serial.println(" ");

  //Check Master Card
  if ((memcmp(readCard, masterCard, 4)) == 0)
  {
    return STATE_SCAN_MASTER;
  }

  if (cardsStored == 0)
  {
    return STATE_SCAN_INVALID;
  }

  for(index = 0; index < cardsStored; index++)
  {
    if ((memcmp(readCard, cardArr[index], 4)) == 0)
    {
      return STATE_SCAN_VALID;
    }
  }

 return STATE_SCAN_INVALID;
}

//------------------------------------------------------------------------------------
void addReadCard()
{
  int cardIndex;
  int index;

  if (cardsStored <= 20)
  {
    cardsStored++;
    cardIndex = cardsStored;
    cardIndex--;
  }

  for(index = 0; index < 4; index++)
  {
    cardArr[cardIndex][index] = readCard[index];
  }
}

//------------------------------------------------------------------------------------
void removeReadCard() 
{     
  int cardIndex;
  int index;
  boolean found = false;
  
  for(cardIndex = 0; cardIndex < cardsStored; cardIndex++)
  {
    if (found == true)
    {
      for(index = 0; index < 4; index++)
      {
        cardArr[cardIndex-1][index] = cardArr[cardIndex][index];
        cardArr[cardIndex][index] = 0;
      }
    }
    
    if ((memcmp(readCard, cardArr[cardIndex], 4)) == 0)
    {
      found = true;
    }
  }

  if (found == true)
  {
    cardsStored--;
  }
}

//------------------------------------------------------------------------------------
void updateState(byte aState)
{
  if (aState == currentState)
  {
    return;
  }

  // do state change
  switch (aState)
  {
    case STATE_STARTING:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("RFID Scanner");
      lcd.setCursor(0,1);
      lcd.print("Starting up");
      StateWaitTime = 1000;
      digitalWrite(REDPIN, HIGH);
      digitalWrite(GREENPIN, HIGH);
      break;
    case STATE_WAITING:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Waiting for Card");
      lcd.setCursor(0,1);
      lcd.print("to be swiped");
      StateWaitTime = 0;
      digitalWrite(REDPIN, LOW);
      digitalWrite(GREENPIN, LOW);
      break;
    case STATE_SCAN_INVALID:
      if (currentState == STATE_SCAN_MASTER)
      {
        addReadCard();
        aState = STATE_ADDED_CARD;
        
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Card Scanned");
        lcd.setCursor(0,1);
        lcd.print("Card Added");
        StateWaitTime = 2000;
        digitalWrite(REDPIN, LOW);
        digitalWrite(GREENPIN, HIGH);
      }
      else if (currentState == STATE_REMOVED_CARD)
      {
        return;
      }
      else
      {
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Card Scanned");
        lcd.setCursor(0,1);
        lcd.print("Invalid Card");
        StateWaitTime = 2000;
        digitalWrite(REDPIN, HIGH);
        digitalWrite(GREENPIN, LOW);
      }
      break;
    case STATE_SCAN_VALID:
      if (currentState == STATE_SCAN_MASTER)
      {
        removeReadCard();
        aState = STATE_REMOVED_CARD;
        
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Card Scanned");
        lcd.setCursor(0,1);
        lcd.print("Card Removed");
        StateWaitTime = 2000;
        digitalWrite(REDPIN, LOW);
        digitalWrite(GREENPIN, HIGH);
      }
      else if (currentState == STATE_ADDED_CARD)
      {
        return;
      }
      else
      {
        lcd.clear();
        lcd.setCursor(0,0);
        lcd.print("Card Scanned");
        lcd.setCursor(0,1);
        lcd.print("valid Card");
        StateWaitTime = 2000;
        digitalWrite(REDPIN, LOW);
        digitalWrite(GREENPIN, HIGH);
      }
      break;
    case STATE_SCAN_MASTER:
      lcd.clear();
      lcd.setCursor(0,0);
      lcd.print("Master Card");
      lcd.setCursor(0,1);
      lcd.print("Cards = ");
      lcd.setCursor(8,1);
      lcd.print(cardsStored);
      StateWaitTime = 5000;
      digitalWrite(REDPIN, LOW);
      digitalWrite(GREENPIN, HIGH);
      break;
  }

  /*lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(aState);
  lcd.setCursor(0,1);
  lcd.print(currentState);*/

  currentState = aState;
  LastStateChangeTime = millis();
}

void setup() 
{
  SPI.begin();         // Init SPI Bus
  mfrc522.PCD_Init();  // Init MFRC522

  lcd.begin(20,4);

  LastStateChangeTime = millis();
  updateState(STATE_STARTING);

  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);

  Serial.begin(9600);
}

void loop() 
{
  byte cardState;

  if ((currentState != STATE_WAITING) &&
      (StateWaitTime > 0) &&
      (LastStateChangeTime + StateWaitTime < millis()))
  {
    updateState(STATE_WAITING);
  }

  // Look for new cards 
  if ( ! mfrc522.PICC_IsNewCardPresent()) 
  { 
    return; 
  } 
  
  // Select one of the cards 
  if ( ! mfrc522.PICC_ReadCardSerial()) 
  { 
    return; 
  }

  cardState = readCardState();
  updateState(cardState);
}

grt Piet.

[nicoverduin Profiel PrivéberichtWebsite]

Ik heb me vanaf het begin al afgevraagd waarom je geen EEPROM ging gebruiken.... Maar volgens mij heb ik recentelijk ook al een heel verhaal gezien met die cards. Ik weet niet of jij het was, maar anders ff zoeken hier op het forum. Met 4 bytes per kaart, zou je 125 kaarten hier kwijt kunnen. Maar als het nummer slechts 4 cijfers is, zou je er zelfs 250 kaarten in kunnen stoppen. Maar ik zou ff zoeken

[bossie Profiel Privébericht]

Ja dat was ik Nico.
Jij had toen voor mij een oplossing, ik had een fout tijdens het compileren.
Het compileren ging prima, maar de applicatie deed niet wat ik voor ogen had.

Ik zit alleen met het verwijderen van een reeds gevalideerde card.
Die wordt dan ergens uit een stapel van cards in de EEPROM gecleared en ik heb zo maar het vermoeden(niet getest overigens) dat als ik dan een gevalideerde kaart scan, die in de stack na de verwijderde komt, dat er dan mogelijk iets fout gaat.

Ik zal iets moeten maken dat er voor zorgt dat de hele inhoud in een variabele array gelezen wordt.
Daar dan de verwijderde kaart 'uithalen' en de array zonder het 'gat' terugschrijven.

Maar misschien bedenk ik wel problemen die er helemaal niet zijn.
Het enige dat ik me zorgen over maak is het beperkte aantal schrijfacties naar de EEPROM
Ik heb ergens gelezen dat dat er 100.000 zijn, is dat 100.000 per geheugen locatie of 100.000 voor de gehele EEPROM
Dat kan ik en de spec's van de ATmega328 niet zo snel terugvinden.
Een SD-card van een beetje kwaliteit kan denk ik veel meer hebben.

grt Piet.

[nicoverduin Profiel PrivéberichtWebsite]

Atmel garandeerd 100000 Write/Erase cycles. Lezen schijnt onbeperkt te zijn. Maar ik heb ook getallen ruim boven de 100K gehoord. Een SD kaart kan inderdaad meer hebben. Maar waarom zou je? Wou jij een seek doen op een SD kaart opzoek naar dat ene nummer uit pak'm beet 1000 stuks? Je moet dan gebufferd lezen en in RAM stoppen... Shit die is beperkt tot 2K kom je niet veel verder.... Ga je zoveel updates doen?..... Is de veranderlijkheid zo groot?
En als een applicatie iets anders doet dan je voor ogen had zou je er goed aan doen om eerst na te denken en dan te doen. M.a.w eerst uitwerken en dan coderen... Beetje net als jullie nu doen in dat fabriekje.... Eerst tekeningen maken aan de hand van specificaties.... dan valideren dat de tekeningen voldoen aan de specificaties en dan maken. Of gaan jullie eerst een beetje trial & error doen, maken maar wat en vragen dan aan de klant of hij/zij dit bedoelde? Lijkt mij niet... Maar bij software ontwikkeling (een vak dat wel heel erg zwart-wit is) doe je dat wel???.... Waar is de kwaliteit gebleven?????

[shooter Profiel Privébericht]

je hoeft toch alleen maar de codes van de kaarten te onthouden?
of wil je ook bijhouden als er iemand binnen komt.

er zijn legio mogelijkheden, en jij krijgt het echt niet voor elkaar om een 100 000 keer de deur te openen hoor.
dan is de deur allang kapot.

[bossie Profiel Privébericht]

je hoeft toch alleen maar de codes van de kaarten te onthouden?
of wil je ook bijhouden als er iemand binnen komt.

zou mooi zijn maar niet direct noodzakelijk.

en jij krijgt het echt niet voor elkaar om een 100 000 keer de deur te openen hoor.
dan is de deur allang kapot.

Dan hangen we er gewoon een nieuwe deur in maar werkt de applicatie nog steeds

Beetje net als jullie nu doen in dat fabriekje.... Eerst tekeningen maken aan de hand van specificaties.... dan valideren dat de tekeningen voldoen aan de specificaties en dan maken.

Welk fabriekje bedoel je Nico?
Ik heb geen idee waar je het over hebt.

Uiteindelijk heb ik dit werkend gekregen:

Code: Alles selecteren

#include <SPI.h>
#include <Wire.h>
#include <MFRC522.h>
#include <LiquidCrystal_I2C.h>
#include <SdFat.h>

#define MFRC_RST_PIN 9
#define MFRC_SS_PIN  10
#define SD_SS_PIN    8

#define STATE_STARTUP       0
#define STATE_STARTUP_ERROR 1
#define STATE_STARTING      2
#define STATE_WAITING       3
#define STATE_SCAN_INVALID  4
#define STATE_SCAN_VALID    5
#define STATE_SCAN_MASTER   6
#define STATE_ADDED_CARD    7
#define STATE_REMOVED_CARD  8

#define REDPIN 6
#define GREENPIN 7
#define RELAYPIN 5

const int cardSize = 4;
byte masterCard[cardSize] = {86,187,140,117};
byte readCard[cardSize] = {0,0,0,0};

// Create MFRC522 instance
MFRC522 mfrc522(MFRC_SS_PIN, MFRC_RST_PIN);
// Set the LCD I2C address
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE);

SdFat sd;

byte currentState = STATE_STARTUP;
unsigned long LastStateChangeTime;
unsigned long StateWaitTime;

char cardFile[] = "cards.txt";
char cardTempFile[] = "cardsTemp.txt";

//------------------------------------------------------------------------------------
void PrintCard(byte printCard[cardSize])
{
  int index;

  Serial.print("Card - ");
  for(index = 0; index < 4; index++)
  {
    if (index > 0)
    {
      Serial.print(",");
    }
    Serial.print(printCard[index]);
  }
  Serial.println(" ");
}

//------------------------------------------------------------------------------------
boolean findCard()
{
  byte currentCard[cardSize];
  char text[10];
  char c1;
  int  index;
  int  value;

  Serial.print("find ");
  PrintCard(readCard);

  // open input file
  ifstream readStr(cardFile);

  // check for open error
  if (!readStr.is_open())
  {
    return false;
  }

  index = 0;
  // read until input fails
  while (!readStr.eof())
  {
    readStr >> value >> c1;

    if (readStr.fail())
    {
      break;
    }

    currentCard[index] = value;
   
    index++;
    if (index > 3)
    {
      Serial.print("file read ");
      PrintCard(currentCard);
      if ((memcmp(currentCard, readCard, 4)) == 0)
      {
        return true;
      }
      index = 0;
    }
  }

  return false;
}

//------------------------------------------------------------------------------------
void addCard()
{
  int index;
  SdFile writeFile;

Serial.print("add ");
PrintCard(readCard);
  Serial.println(cardFile);
  Serial.println(O_RDWR);
  Serial.println(O_CREAT);
  Serial.println(O_AT_END);
  if (writeFile.open(cardFile, O_RDWR | O_CREAT | O_AT_END))
  {
    for(index = 0; index < 4; index++)
    // Serial.print(index);
    {
      writeFile.print(readCard[index]);
      writeFile.print(",");
    }
    writeFile.close();
  }
  return;
}

//------------------------------------------------------------------------------------
void removeCard()
{
  byte currentCard[cardSize];
  char text[10];
  char c1;
  int  readIndex, writeIndex;
  int  value;
  SdFile writeFile;

  //Serial.print("remove ");
  //PrintCard(readCard);

  // open input file
  ifstream readStr(cardFile);

  // check for open error
  if (!readStr.is_open())
  {
    return;
  }

  if (writeFile.open(cardTempFile, O_RDWR | O_CREAT | O_AT_END))
  {
    readIndex = 0;

    while (!readStr.eof())
    {
      readStr >> value >> c1;

      if (readStr.fail())
      {
        break;
      }

      currentCard[readIndex] = value;
   
      readIndex++;
      if (readIndex > 3)
      {
        //Serial.print("file write ");
        //PrintCard(currentCard);
        if (!((memcmp(currentCard, readCard, 4)) == 0))
        {
          for (writeIndex = 0; writeIndex < 4; writeIndex++)
          {
            writeFile.print(currentCard[writeIndex]);
            writeFile.print(",");
          }
          writeFile.close();
        }
      }
      readIndex = 0;
    }
  }

  sd.remove(cardFile);
  sd.rename(cardTempFile, cardFile);
 
  return;
}

//------------------------------------------------------------------------------------
int readCardState()
{
  int index;

  for(index = 0; index < 4; index++)
  {
    readCard[index] = mfrc522.uid.uidByte[index];
  }
  //Serial.print("State ");
  //PrintCard();

  //Check Master Card
  if ((memcmp(readCard, masterCard, 4)) == 0)
  {
    return STATE_SCAN_MASTER;
  }

  if (findCard() == true)
  {
    return STATE_SCAN_VALID;
  }

 return STATE_SCAN_INVALID;
}

//------------------------------------------------------------------------------------
void DisplayInfo(char *Line1Str, char *Line2Str, int RedPinState, int GreenPinState)
{
  lcd.clear();
  lcd.setCursor(0,0);
  lcd.print(Line1Str);
  lcd.setCursor(0,1);
  lcd.print(Line2Str);
  digitalWrite(REDPIN, RedPinState);
  digitalWrite(GREENPIN, GreenPinState);
}

//------------------------------------------------------------------------------------
void updateState(byte aState)
{
  if (aState == currentState)
  {
    return;
  }

  // do state change
  switch (aState)
  {
    case STATE_STARTING:
      DisplayInfo("RFID Scanner", "Starting up", HIGH, HIGH);
      StateWaitTime = 1000;
      break;
     
    case STATE_STARTUP_ERROR:
      DisplayInfo("Error", "SD card", HIGH, HIGH);
      StateWaitTime = 1000;
      break;
     
    case STATE_WAITING:
      digitalWrite(REDPIN, LOW);
      DisplayInfo("Waiting for Card", "to be swiped", HIGH, HIGH);
      StateWaitTime = 1000;
      break;
     
    case STATE_SCAN_INVALID:
      if (currentState == STATE_SCAN_MASTER)
      {
        addCard();
        aState = STATE_ADDED_CARD;

        DisplayInfo("Card Scanned", "Card Added", LOW, HIGH);
        StateWaitTime = 2000;
      }
      else if (currentState == STATE_REMOVED_CARD)
      {
        return;
      }
      else
      {
        DisplayInfo("Card Scanned", "Invalid Card", HIGH, LOW);
        StateWaitTime = 2000;
      }
      break;
     
    case STATE_SCAN_VALID:
      if (currentState == STATE_SCAN_MASTER)
      {
        removeCard();
        aState = STATE_REMOVED_CARD;

        DisplayInfo("Card Scanned", "Card Removed", LOW, HIGH);
        StateWaitTime = 2000;
      }
      else if (currentState == STATE_ADDED_CARD)
      {
        return;
      }
      else
      {
        digitalWrite(RELAYPIN, HIGH);
        DisplayInfo("Card Scanned", "Valid Card", LOW, HIGH);
        StateWaitTime = 2000;
      }
      break;
     
    case STATE_SCAN_MASTER:
      DisplayInfo("Master Card", "", LOW, HIGH);
      StateWaitTime = 5000;
      break;
  }

  //Serial.print("Current State - ");
  //Serial.print(currentState);
  //Serial.print(", New State - ");
  //Serial.println(aState);

  currentState = aState;
  LastStateChangeTime = millis();
}

//------------------------------------------------------------------------------------
void setup()
{
  SPI.begin();         // Init SPI Bus
  mfrc522.PCD_Init();  // Init MFRC522

  if (!sd.begin(SD_SS_PIN, SPI_HALF_SPEED))
  {
    updateState(STATE_STARTUP_ERROR);   
  }

  lcd.begin(20,4);

  LastStateChangeTime = millis();
  updateState(STATE_STARTING);

  pinMode(REDPIN, OUTPUT);
  pinMode(GREENPIN, OUTPUT);
  pinMode(RELAYPIN, OUTPUT);
  digitalWrite(RELAYPIN, LOW);

  Serial.begin(9600);
}

//------------------------------------------------------------------------------------
void loop()
{
  byte cardState;

  if ((currentState != STATE_WAITING) &&
      (currentState != STATE_STARTUP_ERROR) &&
      (StateWaitTime > 0) &&
      (LastStateChangeTime + StateWaitTime < millis()))
  {
    updateState(STATE_WAITING);
  }

  // Look for new cards
  if ( ! mfrc522.PICC_IsNewCardPresent())
  {
    return;
  }
 
  // Select one of the cards
  if ( ! mfrc522.PICC_ReadCardSerial())
  {
    return;
  }

  if (currentState != STATE_STARTUP_ERROR)
  {
    cardState = readCardState();
    updateState(cardState);
  }
}


Ik weet het Nico er staat geen commentaar regel in, dat moet ik nog doen.
Maar het werkt, daar ging het om.

grt Piet.

[nicoverduin Profiel PrivéberichtWebsite]

In je vorige topic had je het over de machine uren teller die mogelijk op meerdere machines zou komen. Dat alleen zou bij mij al suggereren dat er sprake is van een fabrieksmatige oplossing. Waarom zou je voor je eigen omgeving bedrijfsuren tellers willen installeren
Nu heb je het over toegang regelen voor meerdere kaarten.
Samenvattend kwam het bij mij over als iemand die bezig is een werkplaats oid te automatiseren. En vanuit die redenering mijn opmerkingen over de totaal gebrekkige opmerkingen op het gebied van commentaar.
En als het 10 regels bevat is het te overzien. Wordt het veel meer krijg ik steeds meer de neiging om er geen energie meer in te steken. Immers waarom zou ik. De auteur is te beroerd om code te schrijven die voor een ander te volgen is. Dus waarom zou ik er dan nog energie in steken om te achterhalen wat hij/zij bedoeld. Als er een ding in de praktijk geen stand houd is het wel achteraf documenteren.
Maar er zullen altijd wel anderen specialisten zijn die je willen helpen dus geen nood.