Arduino లో EEPROM పరిచయం

ఈ పోస్ట్‌లో మనం EEPROM అంటే ఏమిటి, EEPROM లో నిర్మించిన డేటా ఎలా నిల్వ చేయబడుతుందో అర్థం చేసుకోబోతున్నాం Arduino బోర్డు మైక్రోకంట్రోలర్ మరియు కొన్ని ఉదాహరణల ద్వారా EEPROM లో డేటాను ఎలా వ్రాయాలి మరియు చదవాలో కూడా ఆచరణాత్మకంగా పరీక్షిస్తుంది.

EEPROM ఎందుకు?

EEPROM అంటే ఏమిటి అని మేము అడిగే ముందు? మొదటి స్థానంలో నిల్వ చేయడానికి EEPROM ఎందుకు ఉపయోగించబడుతుందో తెలుసుకోవడం చాలా ముఖ్యం. కాబట్టి, EEPROM లపై మాకు స్పష్టమైన ఆలోచన వస్తుంది.

కంప్యూటర్ హార్డ్ డిస్క్‌లు, పాత పాఠశాల క్యాసెట్ టేప్ రికార్డర్లు, సిడిలు, డివిడిలు, బ్లూ-రే డిస్క్‌లు వంటి ఆప్టికల్ స్టోరేజ్ మాధ్యమం మరియు ఎస్‌ఎస్‌డి (సాలిడ్ స్టేట్ డ్రైవ్) వంటి సాలిడ్ స్టేట్ మెమరీ వంటి మాగ్నెటిక్ స్టోరేజ్ పరికరాల నుండి ఈ రోజుల్లో చాలా నిల్వ పరికరాలు అందుబాటులో ఉన్నాయి. కంప్యూటర్లు మరియు మెమరీ కార్డులు మొదలైనవి.

ఇవి మాస్ స్టోరేజ్ పరికరం, ఇవి సంగీతం, వీడియోలు, పత్రాలు మొదలైన డేటాను తక్కువ కిలోబైట్ల నుండి మల్టీ-టెరాబైట్ల వరకు నిల్వ చేయగలవు. ఇవి అస్థిర మెమరీ అంటే, నిల్వ మాధ్యమానికి శక్తిని కత్తిరించిన తర్వాత కూడా డేటాను నిలుపుకోవచ్చు.

కంప్యూటర్ లేదా స్మార్ట్‌ఫోన్ వంటి చెవి ఓదార్పు సంగీతం లేదా కంటి పాపింగ్ వీడియోలను అందించే పరికరం కాన్ఫిగరేషన్ డేటా, బూట్ డేటా, పాస్‌వర్డ్‌లు, బయో మెట్రిక్ డేటా, లాగిన్ డేటా మొదలైన కొన్ని క్లిష్టమైన డేటాను నిల్వ చేస్తుంది.

భద్రతా కారణాల దృష్ట్యా ఈ పేర్కొన్న డేటాను మాస్ స్టోరేజ్ పరికరాల్లో నిల్వ చేయలేము మరియు ఈ డేటాను వినియోగదారులు అనుకోకుండా సవరించవచ్చు, ఇది పరికరం యొక్క పనిచేయకపోవటానికి దారితీస్తుంది.

ఈ డేటా కొన్ని మెగాబైట్ల నుండి కొన్ని బైట్లు మాత్రమే తీసుకుంటుంది, మాగ్నెటిక్ లేదా ఆప్టికల్ మీడియం వంటి సాంప్రదాయ నిల్వ పరికరాన్ని ప్రాసెసర్ చిప్‌లకు కనెక్ట్ చేయడం ఆర్థికంగా మరియు శారీరకంగా సాధ్యం కాదు.

కాబట్టి, ఈ క్లిష్టమైన డేటా ప్రాసెసింగ్ చిప్స్‌లోనే నిల్వ చేయబడుతుంది.

ఆర్డునో కంప్యూటర్ లేదా స్మార్ట్‌ఫోన్‌ల నుండి భిన్నంగా లేదు. కొన్ని క్లిష్టమైన డేటాను మనం నిల్వ చేయాల్సిన అనేక పరిస్థితులు ఉన్నాయి, ఇవి శక్తిని కత్తిరించిన తర్వాత కూడా తొలగించబడవు, ఉదాహరణకు సెన్సార్ డేటా.

ఇప్పటికి, మైక్రోప్రాసెసర్లు మరియు మైక్రోకంట్రోలర్స్ చిప్‌లపై మాకు EEPROM ఎందుకు అవసరమో మీకు ఒక ఆలోచన వచ్చింది.

EEPROM అంటే ఏమిటి?

EEPROM అంటే ఎలక్ట్రికల్లీ ఎరేజబుల్ ప్రోగ్రామబుల్ రీడ్ ఓన్లీ మెమరీ. ఇది కూడా అస్థిర జ్ఞాపకం, ఇది చదవగలదు మరియు వ్రాయగలదు బైట్ వారీగా.

బైట్-స్థాయి చదవడం మరియు వ్రాయడం ఇతర సెమీకండక్టర్ జ్ఞాపకాల నుండి భిన్నంగా ఉంటుంది. ఉదాహరణకు ఫ్లాష్ మెమరీ: బ్లాక్ వారీగా డేటాను చదవడం, రాయడం మరియు తొలగించడం.

ఒక బ్లాక్ కొన్ని వందల నుండి వేల బిట్స్ కావచ్చు, ఇది సామూహిక నిల్వకు సాధ్యమే, కాని మైక్రోప్రాసెసర్‌లు మరియు మైక్రోకంట్రోలర్‌లలో “రీడ్ ఓన్లీ మెమరీ” ఆపరేషన్ల కోసం కాదు, బైట్ డేటా ద్వారా బైట్‌ను యాక్సెస్ చేయాలి.

Arduino Uno బోర్డు (ATmega328P) లో ఇది బోర్డు 1KB లేదా EEPROM యొక్క 1024 బైట్లను కలిగి ఉంది. ప్రతి బైట్‌ను ఒక్కొక్కటిగా యాక్సెస్ చేయవచ్చు, ప్రతి బైట్‌కు 0 నుండి 1023 వరకు చిరునామా ఉంటుంది (అంటే మొత్తం 1024).

చిరునామా (0-1023) అనేది మన డేటా నిల్వ చేయబడే మెమరీ స్థానం.

ప్రతి చిరునామాలో మీరు 8-బిట్ డేటా, సంఖ్యా అంకెలు 0 నుండి 255 వరకు నిల్వ చేయవచ్చు. మా డేటా బైనరీ రూపంలో నిల్వ చేయబడుతుంది, కాబట్టి మేము 255 నంబర్‌ను EEPROM లోకి వ్రాస్తే అది 11111111 గా అంకెను ఒక చిరునామాలో నిల్వ చేస్తుంది మరియు మేము సున్నా నిల్వ చేస్తే, ఇది 00000000 గా నిల్వ చేయబడుతుంది.

తగిన ప్రోగ్రామ్ రాయడం ద్వారా మీరు టెక్స్ట్, ప్రత్యేక అక్షరాలు, ఆల్ఫాన్యూమరిక్ అక్షరాలు మొదలైన వాటిని కూడా నిల్వ చేయవచ్చు.

నిర్మాణ వివరాలు మరియు పని ఇక్కడ చర్చించబడలేదు, ఇది ఈ వ్యాసాన్ని సుదీర్ఘంగా చేస్తుంది మరియు మేము మీకు నిద్రపోవచ్చు. యూట్యూబ్ లేదా గూగుల్ వైపు వెళ్ళండి, EEPORM నిర్మాణం మరియు పని గురించి ఆసక్తికరమైన కథనం / వీడియోలు ఉన్నాయి.

EEPROM ను EPROM తో కంగారు పెట్టవద్దు:

ఒక్కమాటలో చెప్పాలంటే EPROM అనేది ఎలక్ట్రికల్లీ ప్రోగ్రామబుల్ రీడ్ ఓన్లీ మెమరీ అంటే ఎలక్ట్రికల్‌గా ప్రోగ్రామ్ చేయవచ్చు (స్టోర్ మెమరీ), కానీ విద్యుత్తుగా తొలగించబడదు.

ఇది నిల్వ చేసిన చిప్ పైన ఉన్న అతినీలలోహిత కాంతి యొక్క ప్రకాశవంతమైన షైన్‌ను ఉపయోగిస్తుంది, ఇది నిల్వ చేసిన డేటాను చెరిపివేస్తుంది. EEPROM EPROM కు బదులుగా వచ్చింది మరియు ఇప్పుడు ఏ ఎలక్ట్రానిక్ పరికరాల్లోనూ ఉపయోగించబడలేదు.

EEPROM కోసం ఫ్లాష్ మెమరీని కంగారు పెట్టవద్దు:

ఫ్లాష్ మెమరీ అనేది సెమీకండక్టర్ మరియు అస్థిర మెమరీ, ఇది విద్యుత్ చెరిపివేయగల మరియు విద్యుత్ ప్రోగ్రామబుల్, వాస్తవానికి ఫ్లాష్ మెమరీ EEPROM నుండి తీసుకోబడింది. కానీ బ్లాక్ వారీగా మెమరీ యాక్సెస్ లేదా మరో మాటలో చెప్పాలంటే, మెమరీ మార్గం యాక్సెస్ చేయబడుతుంది మరియు దాని నిర్మాణం EEPROM కి భిన్నంగా ఉంటుంది.

ఆర్డునో యునో (ATmega328P మైక్రోకంట్రోలర్) ప్రోగ్రామ్ నిల్వ కోసం 32KB ఫ్లాష్ మెమరీని కూడా కలిగి ఉంది.

EEPROM యొక్క జీవితకాలం:

ఇతర ఎలక్ట్రానిక్ నిల్వ మాధ్యమాల మాదిరిగానే, EEPROM లో కూడా పరిమిత చదవడం, వ్రాయడం, చెరిపివేసే చక్రాలు ఉన్నాయి. కానీ సమస్య ఏమిటంటే ఇది ఇతర రకాల సెమీకండక్టర్ మెమరీతో పోల్చితే అతి తక్కువ ఆయుర్దాయం కలిగి ఉంటుంది.

Arduino యొక్క EEPROM లో, Atmel ప్రతి సెల్‌కు 100000 (ఒక లక్ష) వ్రాత చక్రం ఉందని పేర్కొంది. మీ గది ఉష్ణోగ్రత తక్కువగా ఉంటే EEPROM యొక్క జీవితకాలం ఎక్కువ.

దయచేసి EEPROM నుండి డేటాను చదవడం జీవితకాలం గణనీయంగా ప్రభావితం చేయదని గమనించండి.

బాహ్య EEPROM IC లు ఉన్నాయి, ఇవి 8 KB, 128KB, 256 KB మొదలైన వాటి నుండి మెమరీ సామర్థ్యంతో సులభంగా ఆర్డునోను ఇంటర్‌ఫేస్ చేయవచ్చు. ప్రతి సెల్‌కు 1 మిలియన్ వ్రాత చక్రాల జీవిత కాలం ఉంటుంది.

అది EEPROM ను ముగించింది, ఇప్పుడు మీరు EEPROM ల గురించి తగినంత సైద్ధాంతిక జ్ఞానాన్ని పొందారు.

కింది విభాగంలో ఆర్డునోపై EEPROM ను ఆచరణాత్మకంగా ఎలా పరీక్షించాలో నేర్చుకుంటాము.

Arduino లో EEPROM ను ఎలా పరీక్షించాలి

దీన్ని అమలు చేయడానికి, మీకు కావలసిందల్లా ఒక USB కేబుల్ మరియు Arduino Uno బోర్డు, మీరు వెళ్ళడానికి సిద్ధంగా ఉన్నారు.

పై వివరణల నుండి, మన డేటాను నిల్వ చేసే చోట EEPROM లకు చిరునామా ఉందని మేము అర్థం చేసుకున్నాము. మేము ఆర్డునో యునోలో 0 నుండి 1023 స్థానాలను నిల్వ చేయవచ్చు. ప్రతి ప్రదేశంలో 8-బిట్స్ లేదా ఒక బైట్ ఉంటుంది.

ఈ ఉదాహరణలో మేము డేటాను చిరునామాలో నిల్వ చేయబోతున్నాము. ప్రోగ్రామ్ యొక్క సంక్లిష్టతను తగ్గించడానికి మరియు ప్రోగ్రామ్‌ను సాధ్యమైనంత తక్కువగా ఉంచడానికి, మేము 0 నుండి 9 వరకు చిరునామాలో ఒకే అంకెల పూర్ణాంకాన్ని (0 నుండి 9 వరకు) నిల్వ చేయబోతున్నాము.

ప్రోగ్రామ్ కోడ్ # 1

ఇప్పుడు, కోడ్‌ను ఆర్డునోకు అప్‌లోడ్ చేయండి:
//------------------Program Developed by R.GIRISH-------------------//
#include
int inputAddress = 0
int inputValue = 0
int ReadData = 0
boolean Readadd = true
boolean Readval = true
void setup()
{
Serial.begin(9600)
Serial.println('Enter the address (0 to 9)')
Serial.println('')
while(Readadd)
{
inputAddress = Serial.read()
if(inputAddress > 0)
{
inputAddress = inputAddress - 48
Readadd = false
}
}
Serial.print('You have selected Address: ')
Serial.println(inputAddress)
Serial.println('')
delay(2000)
Serial.println('Enter the value to be stored (0 to 9)')
Serial.println('')
while(Readval)
{
inputValue = Serial.read()
if(inputValue > 0)
{
inputValue = inputValue - 48
Readval = false
}
}
Serial.print('The value you entered is: ')
Serial.println(inputValue)
Serial.println('')
delay(2000)
Serial.print('It will be stored in Address: ')
Serial.println(inputAddress)
Serial.println('')
delay(2000)
Serial.println('Writing on EEPROM.....')
Serial.println('')
EEPROM.write(inputAddress, inputValue)
delay(2000)
Serial.println('Value stored successfully!!!')
Serial.println('')
delay(2000)
Serial.println('Reading from EEPROM....')
delay(2000)
ReadData = EEPROM.read(inputAddress)
Serial.println('')
Serial.print('The value read from Address ')
Serial.print(inputAddress)
Serial.print(' is: ')
Serial.println(ReadData)
Serial.println('')
delay(1000)
Serial.println('Done!!!')
}
void loop()
{
// DO nothing here.
}
//------------------Program Developed by R.GIRISH-------------------//

అవుట్పుట్:

కోడ్ అప్‌లోడ్ అయిన తర్వాత, సీరియల్ మానిటర్‌ను తెరవండి.

ఇది 0 నుండి 9 వరకు చిరునామాను నమోదు చేయమని అడుగుతుంది. పై అవుట్పుట్ నుండి, నేను చిరునామా 3 ను ఎంటర్ చేసాను. కాబట్టి, నేను స్థానం (చిరునామా) 3 లో పూర్ణాంక విలువను నిల్వ చేస్తాను.

ఇప్పుడు, ఇది 0 నుండి 9 వరకు ఒకే అంకెల పూర్ణాంక విలువను నమోదు చేయమని మిమ్మల్ని అడుగుతుంది. పై అవుట్పుట్ నుండి, నేను విలువ 5 ని నమోదు చేసాను.

కాబట్టి, ఇప్పుడు విలువ 5 చిరునామా స్థానం 3 లో నిల్వ చేయబడుతుంది.

మీరు విలువను నమోదు చేసిన తర్వాత, అది EEPROM లో విలువను వ్రాస్తుంది.

ఇది విజయ సందేశాన్ని చూపుతుంది, అంటే విలువ నిల్వ చేయబడుతుంది.

కొన్ని సెకన్ల తరువాత ఇది వ్యాఖ్యానించిన చిరునామాలో నిల్వ చేయబడిన విలువను చదువుతుంది మరియు ఇది సీరియల్ మానిటర్‌లో విలువను చూపుతుంది.

ముగింపులో, మేము ఆర్డునో యొక్క మైక్రోకంట్రోలర్ యొక్క EEPROM నుండి విలువలను వ్రాసాము మరియు చదివాము.

ఇప్పుడు, మేము పాస్వర్డ్ను నిల్వ చేయడానికి EEPROM ను ఉపయోగించబోతున్నాము.

మేము 6 అంకెల సంఖ్య (తక్కువ లేదా అంతకంటే ఎక్కువ) పాస్‌వర్డ్‌ను నమోదు చేస్తాము, ఇది 6 వేర్వేరు చిరునామాలలో (ప్రతి అంకెకు ప్రతి చిరునామా) మరియు “1” లేదా “0” ని నిల్వ చేయడానికి ఒక అదనపు చిరునామాలో నిల్వ చేయబడుతుంది.

మీరు పాస్‌వర్డ్‌ను నమోదు చేసిన తర్వాత, అదనపు చిరునామా పాస్‌వర్డ్ సెట్ చేయబడిందని సూచించే “1” విలువను నిల్వ చేస్తుంది మరియు ప్రోగ్రామ్ ఎల్‌ఇడిని ఆన్ చేయడానికి పాస్‌వర్డ్‌ను నమోదు చేయమని అడుగుతుంది.

అదనపు చిరునామా నిల్వ విలువ “0” లేదా మరేదైనా విలువ ఉంటే, అది క్రొత్త 6 అంకెల పాస్‌వర్డ్‌ను సృష్టించమని అడుగుతుంది.

పై పద్ధతి ద్వారా, మీరు ఇప్పటికే పాస్‌వర్డ్‌ను సెట్ చేశారా లేదా క్రొత్త పాస్‌వర్డ్‌ను సృష్టించాల్సిన అవసరం ఉందా అని ప్రోగ్రామ్ గుర్తించగలదు.

ఎంటర్ చేసిన పాస్‌వర్డ్ సరైనది అయితే పిన్ # 13 గ్లోస్‌లో ఎల్‌ఇడిలో నిర్మించడం, ఎంటర్ చేసిన పాస్‌వర్డ్ తప్పుగా ఉంటే, ఎల్‌ఇడి మెరుస్తూ ఉండదు మరియు సీరియల్ మానిటర్ మీ పాస్‌వర్డ్ తప్పు అని అడుగుతుంది.

ప్రోగ్రామ్ కోడ్ # 2

ఇప్పుడు కోడ్‌ను అప్‌లోడ్ చేయండి:
//------------------Program Developed by R.GIRISH---------------//
#include
int passExistAdd = 200
const int LED = 13
int inputAddress = 0
int word1 = 0
int word2 = 0
int word3 = 0
int word4 = 0
int word5 = 0
int word6 = 0
int wordAddress1 = 0
int wordAddress2 = 1
int wordAddress3 = 2
int wordAddress4 = 3
int wordAddress5 = 4
int wordAddress6 = 5
int passwordExist = 0
boolean ReadVal1 = true
boolean ReadVal2 = true
boolean ReadVal3 = true
boolean ReadVal4 = true
boolean ReadVal5 = true
boolean ReadVal6 = true
int checkWord1 = 0
int checkWord2 = 0
int checkWord3 = 0
int checkWord4 = 0
int checkWord5 = 0
int checkWord6 = 0
void setup()
{
Serial.begin(9600)
pinMode(LED, OUTPUT)
digitalWrite(LED, LOW)
passwordExist = EEPROM.read(passExistAdd)
if(passwordExist != 1)
{
Serial.println('Enter a new 6 number password:')
while(ReadVal1)
{
word1 = Serial.read()
if(word1 > 0)
{
word1 = word1 - 48
ReadVal1 = false
}
}
while(ReadVal2)
{
word2 = Serial.read()
if(word2 > 0)
{
word2 = word2 - 48
ReadVal2 = false
}
}
while(ReadVal3)
{
word3 = Serial.read()
if(word3 > 0)
{
word3 = word3 - 48
ReadVal3 = false
}
}
while(ReadVal4)
{
word4 = Serial.read()
if(word4 > 0)
{
word4 = word4 - 48
ReadVal4 = false
}
}
while(ReadVal5)
{
word5 = Serial.read()
if(word5 > 0)
{
word5 = word5 - 48
ReadVal5 = false
}
}
while(ReadVal6)
{
word6 = Serial.read()
if(word6 > 0)
{
word6 = word6 - 48
ReadVal6 = false
}
}
Serial.println('')
Serial.print(word1)
Serial.print(word2)
Serial.print(word3)
Serial.print(word4)
Serial.print(word5)
Serial.print(word6)
EEPROM.write(wordAddress1, word1)
EEPROM.write(wordAddress2, word2)
EEPROM.write(wordAddress3, word3)
EEPROM.write(wordAddress4, word4)
EEPROM.write(wordAddress5, word5)
EEPROM.write(wordAddress6, word6)
EEPROM.write(passExistAdd,1)
Serial.println(' Password saved Sucessfully!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
if(passwordExist == 1)
{
Serial.println('')
Serial.println('Please enter the 6 digit number password:')
while(ReadVal1)
{
word1 = Serial.read()
if(word1 > 0)
{
word1 = word1 - 48
ReadVal1 = false
}
}
while(ReadVal2)
{
word2 = Serial.read()
if(word2 > 0)
{
word2 = word2 - 48
ReadVal2 = false
}
}
while(ReadVal3)
{
word3 = Serial.read()
if(word3 > 0)
{
word3 = word3 - 48
ReadVal3 = false
}
}
while(ReadVal4)
{
word4 = Serial.read()
if(word4 > 0)
{
word4 = word4 - 48
ReadVal4 = false
}
}
while(ReadVal5)
{
word5 = Serial.read()
if(word5 > 0)
{
word5 = word5 - 48
ReadVal5 = false
}
}
while(ReadVal6)
{
word6 = Serial.read()
if(word6 > 0)
{
word6 = word6 - 48
ReadVal6 = false
}
}
checkWord1 = EEPROM.read(wordAddress1)
if(checkWord1 != word1)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord2 = EEPROM.read(wordAddress2)
if(checkWord2 != word2)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord3 = EEPROM.read(wordAddress3)
if(checkWord3 != word3)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord4 = EEPROM.read(wordAddress4)
if(checkWord4 != word4)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord5 = EEPROM.read(wordAddress5)
if(checkWord5 != word5)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
checkWord6 = EEPROM.read(wordAddress6)
if(checkWord6 != word6)
{
Serial.println('')
Serial.println('Wrong Password!!!')
Serial.println('')
Serial.println('Press Reset Button.')
while(true){}
}
digitalWrite(LED, HIGH)
Serial.println('')
Serial.println('LED is ON')
Serial.println('')
Serial.println('Press Reset Button.')
}
}
void loop()
{
}
//------------------Program Developed by R.GIRISH---------------//

అవుట్పుట్:

సీరియల్ మానిటర్‌ను తెరవండి, ఇది 6 అంకెల సంఖ్య పాస్‌వర్డ్‌ను సృష్టించమని మిమ్మల్ని అడుగుతుంది.

ఏదైనా 6 అంకెల పాస్‌వర్డ్‌ను నమోదు చేసి, దాన్ని గమనించండి మరియు ఎంటర్ నొక్కండి. ఇప్పుడు పాస్వర్డ్ నిల్వ చేయబడింది.

మీరు రీసెట్ బటన్‌ను నొక్కవచ్చు లేదా PC నుండి USB కేబుల్‌ను డిస్‌కనెక్ట్ చేయవచ్చు, ఇది Arduino బోర్డ్‌కు సరఫరా అంతరాయం కలిగిస్తుంది.

ఇప్పుడు, USB కేబుల్, ఓపెన్ సీరియల్ మానిటర్‌ను తిరిగి కనెక్ట్ చేయండి, ఇది సేవ్ చేసిన 6 అంకెల పాస్‌వర్డ్‌ను నమోదు చేయమని మిమ్మల్ని అడుగుతుంది.

LED మెరుస్తున్న సరైన పాస్‌వర్డ్‌ను నమోదు చేయండి.

మీరు పాస్‌వర్డ్ మార్చాలనుకుంటే కోడ్ నుండి అంకెను మార్చండి:

int passExistAdd = 200

పైన పేర్కొన్న పంక్తి మేము ముందు చర్చించిన అదనపు చిరునామా. 6 నుండి 1023 వరకు ఎక్కడైనా మార్చండి. 6 అంకెల పాస్‌వర్డ్‌ను నిల్వ చేయడానికి 0 నుండి 5 చిరునామాలు ప్రత్యేకించబడ్డాయి.

ఈ అదనపు చిరునామాను మార్చడం వలన పాస్‌వర్డ్ ఇంకా సృష్టించబడని ప్రోగ్రామ్‌ను అవివేకిని చేస్తుంది మరియు క్రొత్త 6 అంకెల పాస్‌వర్డ్‌ను సృష్టించమని మిమ్మల్ని అడుగుతుంది.

Arduino ట్యుటోరియల్‌లో ఈ EEPROM గురించి మీకు ఏవైనా ప్రశ్నలు ఉంటే, దయచేసి వ్యాఖ్యలలో వ్యక్తపరచండి, మీకు శీఘ్ర సమాధానం లభిస్తుంది.