How to make a copy of the key for the intercom at home. A simple do-it-yourself intercom key duplicator Do-it-yourself intercom key copying

Each intercom key has its own number - it is this number that serves as the key identifier. It is by the number of the key that the intercom decides - its own or someone else's. Therefore, the copying algorithm is as follows: first you need to find out the number of the allowed key, and then assign this number to another key - the clone. For the intercom, it makes no difference whether the original key or its copy was attached. After checking the number with his database of allowed numbers, he will open the door.

Intercom keys that we will connect to the Arduino (they are sometimes called iButton or touch memory) are read and written via 1-wire interface. Therefore, the connection scheme is very simple. All we need is a couple of wires and a 2.2 kΩ pull-up resistor. The connection diagram is shown in the figure.

The assembled circuit might look something like this:


2 Read iButton Key ID using Arduino

To work with the 1-wire interface, there are ready-made libraries for Arduino. You can use, for example, this one. Download the archive and unpack it into a folder /libraries/ located in the Arduino IDE directory. Now we can very simply work with this protocol.

Upload this sketch to Arduino in the standard way:

iButton Key Reading Sketch with Arduino(expands) #include OneWire iButton(10); // create a 1-wire object on pin 10 void setup(void)( Serial.begin(9600); ) void loop(void) ( delay(1000); // delay 1 sec byte addr; // array for storing key data if (!iButton.search(addr)) ( // if the key is not attached Serial.println("No key connected..."); // report this return; // and abort the program ) Serial.print("Key: "); for(int i=0; i )

This sketch shows the key number for the intercom that is connected to the circuit. This is what we need now: we need to find out the number of the key we want to make a copy of. Let's connect the Arduino to the computer. Let's start the serial port monitor: Tools Serial Port Monitor(or keyboard shortcut Ctrl+Shift+M).

Now let's connect the key to the circuit. The port monitor will show the key number. Let's remember this number.


And here is what exchange takes place on a single-wire line when reading the key identifier (for more details, see below):

The figure, of course, does not show all the implementation details. Therefore, at the end of the article, I attach a timing diagram in the *.logicdata format, taken with the help of a logic analyzer and the program Saleae Logic Analyzer and opened to her. The program is free and can be downloaded from the official Saleae website. To open the *.logicdata file, you need to run the program, press Ctrl + O or in the menu Options(located at the top right) select an item open capture / setup.

3 Dallas Key Identifier Record using Arduino

Now let's write a sketch for writing data to the memory of the iButton key.

iButton key writing sketch with Arduino(expands) #include // include the library const int pin = 10; // declare the OneWire pin number iButton(pin); // declare OneWire object on pin 10 // key number we want to write to iButton: byte key_to_write = ( 0x01, 0xF6, 0x75, 0xD7, 0x0F, 0x00, 0x00, 0x9A ); void setup(void) ( Serial.begin(9600); pinMode(pin, OUTPUT); ) void loop(void) ( delay(1000); // delay by 1 sec iButton.reset(); // device reset 1-wire delay(50); iButton.write(0x33); // send "read" command byte data; // array for storing key data iButton.read_bytes(data, 8); // read the data of the attached key, 8x8=64 bits if (OneWire::crc8(data, 7) != data) ( // check the checksum of the attached key Serial. println("CRC error!"); // if the CRC is not correct, report it return; // and abort the program ) if (data & data & data & data & data & data & data & data == 0xFF) ( return; // if the key is not applied to to the reader, abort the program and wait for the ) to be applied Serial.print("Start programming..."); // start of the process of writing data to the key for (int i = 0; i ) // Initialization of writing data to the iButton key-tablet: void send_programming_impulse() ( digitalWrite(pin, HIGH); delay(60); digitalWrite(pin, LOW); delay(5); digitalWrite(pin, HIGH); delay(50); }

Don't forget to set the number of your original key in the array key_to_write which we learned earlier.

Upload this sketch to the Arduino. Open the serial port monitor (Ctrl+Shift+M). Let's connect a key to the scheme, which will be a clone of the original key. The serial port monitor will display a corresponding message about the result of programming.

If this sketch didn't work, try replacing the code after Serial.print("Start programming...") until the end of the function loop() to the next one:

Additional sketch for writing iButton key using Arduino(expand) delay(200); iButton.skip(); iButton.reset(); iButton.write(0x33); // read current key number Serial.print("ID before write:"); for (byte i=0; i<8; i++){ Serial.print(" "); Serial.print(iButton.read(), HEX); } Serial.print("\n"); iButton.skip(); iButton.reset(); iButton.write(0xD1); // команда разрешения записи digitalWrite(pin, LOW); pinMode(pin, OUTPUT); delayMicroseconds(60); pinMode(pin, INPUT); digitalWrite(pin, HIGH); delay(10); // выведем ключ, который собираемся записать: Serial.print("Writing iButton ID: "); for (byte i=0; i<8; i++) { Serial.print(key_to_write[i], HEX); Serial.print(" "); } Serial.print("\n"); iButton.skip(); iButton.reset(); iButton.write(0xD5); // команда записи for (byte i=0; i<8; i++) { writeByte(key_to_write[i]); Serial.print("*"); } Serial.print("\n"); iButton.reset(); iButton.write(0xD1); // команда выхода из режима записи digitalWrite(pin, LOW); pinMode(pin, OUTPUT); delayMicroseconds(10); pinMode(pin, INPUT); digitalWrite(pin, HIGH); delay(10); Serial.println("Success!"); delay(10000);

Here the function writeByte() will be as follows:

int writeByte(byte data) ( int data_bit; for(data_bit=0; data_bit<8; data_bit++) { if (data & 1) { digitalWrite(pin, LOW); pinMode(pin, OUTPUT); delayMicroseconds(60); pinMode(pin, INPUT); digitalWrite(pin, HIGH); delay(10); } else { digitalWrite(pin, LOW); pinMode(pin, OUTPUT); pinMode(pin, INPUT); digitalWrite(pin, HIGH); delay(10); } data = data >> 1; ) return 0; )

It is pointless to show the timing diagram of the operation of the key identifier recording sketch, because it is long and will not fit in the picture. However, the *.logicdata file for the logic analyzer program is attached at the end of the article.

Intercom keys come in different types. This code is not suitable for all keys, but only for RW1990 or RW1990.2. Programming keys of other types can lead to key failure!

If desired, you can rewrite the program for a key of a different type. To do this, use the technical description of your key type (datasheet) and change the sketch in accordance with the description. Download datasheet for iButton keys can be attached to the article.

By the way, some modern intercoms read not only the key identifier, but also other information recorded on the original key. Therefore, making a clone by copying only the number will not work. You need to completely copy the key data.

4 Description of single wire 1-Wire interface

Let's take a closer look at the One-wire interface. In organization, it is similar to the I2C interface: it must also contain a master device (master) that initiates the exchange, as well as one or more slave devices (slave). All devices are connected to one common bus. iButton devices are always slaves. The master is usually a microcontroller or PC. The data rate is 16.3 kbps. The idle bus is at logic "1" (HIGH). This protocol provides only 5 types of signals:

  • reset pulse (master)
  • presence pulse (slave)
  • write bit "0" (master)
  • write bit "1" (master)
  • read bit (master)
With the exception of the presence pulse, all others are generated by the master. The exchange always takes place according to the scheme: 1) Initialization 2) Commands for working with ROM 3) Commands for working with PROM 4) Data transfer.

1) Initialization

Initialization consists in the fact that the master sets the reset condition RESET (lowers the line to "0" for a period of 480 µs or more, and then releases it, and due to the pull-up resistor, the line rises to the state "1"), and the slave must confirm the presence no later than 60 µs after that, also lowering the line to "0" for 60 ... 240 µs and then freeing it:


2) Commands for working with ROM

If no acknowledgment signal is received after the initialization pulse, the master repeats the polling of the bus. If the confirmation signal is received, then the master understands that there is a device on the bus that is ready for the exchange, and sends it one of the four 8-bit ROM commands:

(*) By the way, there are quite a few families of iButton devices, some of them are listed in the table below.

iButton family codes(unfolds)
Family codeiButton devicesDescription
0x01DS1990A, DS1990R, DS2401, DS2411Unique serial number-key
0x02DS1991Multikey, 1152-bit secure EEPROM
0x04DS1994, DS24044 kb NV RAM + clock, timer and alarm
0x05DS2405Single addressable key
0x06DS19934 KB NV RAM
0x08DS19921 KB NV RAM
0x09DS1982, DS25021 kb PROM
0x0ADS199516 KB NV RAM
0x0BDS1985, DS250516 KB EEPROM
0x0CDS199664 KB NV RAM
0x0FDS1986, DS250664 KB EEPROM
0x10DS1920, DS1820, DS18S20, DS18B20temperature sensor
0x12DS2406, DS24071 kb EEPROM + dual channel addressable key
0x14DS1971, DS2430A256 bit EEPROM and 64 bit PROM
0x1ADS1963L4 KB NV RAM + write cycle counter
0x1CDS28E04-1004 KB EEPROM + dual channel addressable key
0x1DDS24234 KB NV RAM + external counter
0x1FDS2409Two-channel addressable key with the possibility of switching to the return bus
0x20DS2450Four-channel ADC
0x21DS1921G, DS1921H, DS1921ZThermochronic sensor with data acquisition function
0x23DS1973, DS24334 kb EEPROM
0x24DS1904, DS2415Real time clock
0x26DS2438Temperature sensor, ADC
0x27DS2417Real time clock with interrupt
0x29DS2408Bidirectional 8-bit I/O port
0x2CDS2890Single channel digital potentiometer
0x2DDS1972, DS24311 kb EEPROM
0x30DS2760Temperature sensor, current sensor, ADC
0x37DS197732 KB password protected EEPROM
0x3ADS2413Dual Channel Addressable Switch
0x41DS1922L, DS1922T, DS1923, DS2422High-resolution thermochronic and hygrochronous sensors with data acquisition
0x42DS28EA00Digital thermometer with programmable resolution, serial link capability and programmable I/O ports
0x43DS28EC2020 kb EEPROM

Data is transmitted sequentially, bit by bit. The transmission of each bit is initiated by the master. When recording, the leader lowers the line to zero and holds it. If the line holding time is 1…15 µs, then bit "1" is written. If the hold time is 60 µs or more, bit "0" is written.

Reading bits is also initiated by the master. At the start of reading each bit, the master pulls the bus low. If the slave wants to send a "0", it holds the bus in the LOW state for 60 to 120 µs, and if it wants to send a "1", it keeps the bus in the LOW state for about 15 µs. After that, the slave releases the line, and due to the pull-up resistor, it returns to the HIGH state.

This is how, for example, the timing diagram of the Search ROM (0xF0) search command looks. Bit writing commands are marked in red in the diagram. Pay attention to the order of the bits when transmitting over 1-Wire: the most significant bit is on the right, the least significant bit is on the left.


3) Commands for working with PROM

Before considering the commands for working with the iButton PROM, it is necessary to say a few words about the dongle memory structure. The memory is divided into 4 equal sections: three of them are designed to store three unique keys, and the fourth is for temporary data storage. This temporary buffer serves as a kind of draft where data is prepared for writing keys.


To work with the PROM, there are 6 commands:

NameTeamPurpose
Write to temporary buffer (Write Scratchpad)0x96Used to write data to a temporary buffer (scratchpad).
Read from temporary buffer (Read Scratchpad)0x69Used to read data from a temporary buffer.
Copy from temporary clipboard (Copy Scratchpad)0x3CUsed to transfer data prepared in a temporary buffer to the selected key.
Write key password (Write Password)0x5AUsed to record the password and unique identifier of the selected key (one of three).
Write a key (Write SubKey)0x99Used to directly write data to the selected key (bypassing the temporary buffer).
Read Key (Read SubKey)0x66Used to read the data of the selected key.

4) Data transfer

To be continued...

5 Possible mistakes when compiling the sketch

1) If an error occurs while compiling the sketch WConstants.h: No such file or directory #include "WConstants.h", then, as an option, follows in the file OneWire.cpp replace the first block after the comments with the following:

#include #include extern "C" (#include #include }

2) If an error occurs during compilation class OneWire has no member named read_bytes, then find and try to use another library to work with the OneWire interface.

Good afternoon Somehow I got tired of paying 150 rubles for a copy of the intercom key and decided to assemble a simple, budget iButton duplicator on Arduino. The prices for such ready-made devices “bite”, although their functionality is wider, they copy almost everything, including wireless dongles. A simple copy of the iButton key a la "button" is enough for me. Interesting? Please under "cut"!

So let's get started! To begin with, "technical assignment", what should this device be able to do:
1) Read the contents of the key, it's interesting what is sewn up there.
2) Copy the keys, no matter how strange it sounds :)
3) Flash the "universal" key. By the word "universal" we mean any of our own keys, which will be recorded by default.

UPD. Very important! If the first byte, family code, is 00 , For example 00 :12:34:56:AB:CD:EF: AA, then after the firmware the key will “die”, it will not be read by this programmer, and possibly by others. Found by experience, thanks to a friend 16 :AB:CD:EF:E0 with a naturally incorrect checksum E0. Since the checksum is incorrect, the intercom ignores this sequence when reading. This intercom ruined all rewritable keys, while I figured out what was the matter and why the data in the keys “by itself” changes. As a result, it was not possible to make a duplicate for this intercom, I had to go to a service organization and order a key for 100 rubles. :)


As a result, we get a thing useful in the household for ridiculous money, “blanks” for recording are sold, although we can find offline for 30 rubles apiece, for copiers on the market for 100 - 150 rubles :).
UPD. We read about what types of keys can be written with this duplicator. Thanks for the help comrade.
UPD. If the key is not written, follow the comrade. I plan to buy +191 Add to favorites Liked the review +95 +184

Good day to all!
I would like to bring to your attention a duplicator (copier) of intercom keys.
The copier can read / write to a key fob or card.
I have long wanted to try out an inexpensive device for copying keys from an intercom. And now this moment has come, so let's get started.

The order came in 3 weeks.

Intercom keys. A small educational program.

The keys are:

  • Contact. Official name Touch memory (abbr. TM) or iButton
(i.e. they must be applied to the reader)
These include:

Dallas.

In most cases, TM means a Dallas family key (for example, DS1990A). Many devices work with these keys: Vizit, Eltis, Z-5R, С2000-2, etc.

Cyfral.

These intercoms work only with DC2000A and Tsifral-KP1 keys.

Metakom.

K1233KT2 keys have been developed for these intercoms. These keys are suitable for many other controllers.

Resistive.

There are exotic intercoms that work with resistive keys. Instead of a code, resistance is read from them. Without a doubt, these are contact keys, but I would not call them Touch memory.
  • Contactless. The official name of RFID.
(they just need to be brought to the reader at a distance of 2-3 cm).

They are issued in the form of cards, key rings, bracelets, etc. The common name is “cards” and “drops” (key rings). Keys operating up to 10-15 cm are called Proximity (short-range), and operating up to 1 m - Vicinity (long-range). Intercoms use exclusively Proximity keys, and this term has become almost synonymous with "contactless key".

In the world of Proximity, there is also no unity of formats:

EM Marin

the most popular format today.

HID

elder among contactless keys.

MIFARE

perspective format. This includes contactless smart cards.

This device is designed EXCLUSIVELY to copy 125KHz proximity keys.
No other keys can be copied.

Parcel content:






Contents of delivery:

- RFID 125KHz EM4100 ID Card Copier;
- rewritable key chains 6pcs;
- rewritable cards 6 pcs.;
- instructions (English-Chinese).
AAA batteries are not included.

Appearance of the device:






The insides of the device:










Device in the on position:


(the red light is on, it means the device is on)

Key internals:


Instruction:




  • Copy process:
1. Insert two AAA batteries.
2. Turn on the toggle switch located on the right side (the red indicator with the inscription POWER lights up and two short beeps are emitted).
3. We bring the card or keychain to the left sidewall, at the level of the inscription POWER.
4. Press the "READ" button. In response, the duplicator will beep 2 times and the green LED with the inscription "PASS" will light up
5. We remove the card or keychain from which the label was counted.
6. Bring a rewritable card or key fob to the copier. Press the "WRITE" button. For a while, the yellow LED with the inscription BUSY will light up and again a double squeak will be heard. All new key fob or card can be used.

Video of the process of reading and writing:

Outcome.

Everything works great. If you need to make several copies of RFID 125KHz keys, you can safely buy, especially since there are 6 key fobs and 6 cards in the kit, and the average price for one copy is 100 rubles, the benefit is obvious. If key rings or cards run out on the Internet, you can buy within 20 rubles.
Before buying this device, I recommend that you find out the frequency and type of your key, otherwise you will throw money away.

If you liked the review, or helped in choosing a device, put likes, this is your best reward for my work.
Thank you all for your attention!

The product was provided for writing a review by the store. The review is published in accordance with clause 18 of the Site Rules.

I plan to buy +88 Add to favorites Liked the review +44 +83

Everyone knows that any mechanism deteriorates over time, and it has to be changed, especially for elements subject to frequent physical exertion.

Electronics in this sense is more reliable, and if it is well protected electrically, it can last quite a long time.

The loss of keys from a mechanical lock is often associated with the replacement of the latter. Losing an electronic chip, it is enough to make a copy of it using.

How a duplicator is arranged and works

What models and types of key duplicators are

All duplicators of intercom keys available in nature can be classified into three different types:

  1. Programmers for flashing contactless keys tmd;
  2. Duplicators for making copies of contact intercom keys;
  3. A universal type of duplicators that can reflash any kind of intercom chips.

Each of these types of devices have their modifications.

Contactless Duplicators

Among them there are three modifications of devices.

The first modification includes programmers that make the RFID standard EM-Marin, HID and Indala (tmd duplicators), the second modification supports the Mifare standard, the third modification of the duplicators works with keys of the TECH-COM or TKRF standard.

Contact type devices

Devices are presented in two types. The first type is designed to work with dallas contact type keys, the second type of programmers duplicates type keys or.

The Dallas chip has a hexadecimal code, and the digital one is flashed with a protocol type code, which is large in size.

Universal key programming devices

Universal intercom key duplicators, in addition to being able to create a copy of any digital chip, have a number of additional functions:

  • Ability to update;
  • The presence of a memory base;
  • Code generation.

Considering the first function, it must be said that when new modifications of keys with the original encoding are released, the base of the programming device can be flashed for these chips, and it will be able to make copies of them.

The second function makes it possible to clone keys without the original. That is, after the first flashing, the chip code is simply written to the device base and reproduced as needed.

The third function allows you to flash keys with original codes, for example, for company employees, each of whom must have their own personal access code to the lock. Then you can track the number of visits to a particular object by a specific person.

What you need to make a do-it-yourself intercom key duplicator

When making a key copier with your own hands, you can take the Arduino module as a basis.

The element base that will be needed to manufacture the device:

  1. The microcontroller of the “Arduino Nano” type is the main “brains” of the device, where information is processed and data is recorded;
  2. RFID RC522 board, which acts as a module that reads codes and redirects information to the microcontroller;
  3. Piezoelectric type buzzer;
  4. Two LED elements for the monitor;
  5. Two 330 ohm resistors;
  6. Keyboard block type 4X4;
  7. I2C type liquid crystal display adapter (LCM1602), which acts as an LCD converter to an Arduino-compatible format;
  8. Liquid crystal display type LCD16X2BL.

The liquid crystal screen is connected to the contact group of the adapter using sixteen pins. On both modules, the contacts are numbered.

Next, power wires are connected to the display adapter from the rf ID RC522 module: red - to the VCC (+) contact and black - to the GND (common) contact. The control wires are soldered to the SDA and SCL pins. LED elements are installed in tandem with current limiting resistors.

The principle of flashing keys

Intercom chips, which are in the form of tablets and whose surface must be applied to the intercom contact, do not contain magnetic elements inside.

The circuitry of the device is based on the use of non-volatile memory (in other words, ROM).

In such a memory, a sequence of characters of a digital unique code is written.

The principle of rewriting such keys is that the tmd duplicator reads the code and recreates it on a pure chip platform.

The RFID system is built on the transmission of a code not by contact, but by a certain radio frequency.

The key circuit contains an oscillatory circuit. If it is excited, the data from the memory will be transmitted to the reader through space.

Such an excitatory signal will be a signal coming from the antenna of the intercom or duplicator. Otherwise, the principle of how to copy the code into memory, its further reproduction is no different from the principle of operation of the contact device.

The only difference is that programmers can only store and play back a certain type of digital signal. The exception is universal devices that can be programmed to work with any type of digital data.

Conclusion

Making chips for an intercom with your own hands can be not only a solution to the problem of losing personal keys, but also an opportunity to build your business on it.

To begin with, you can make a simple intercom key copier for the most popular “blanks”.

The most important thing is that such earnings do not require large initial investments, and services will always be in demand, especially in large cities.

Video: Do-it-yourself intercom key duplicator

As a means of protecting the front doors of houses from uninvited guests, they are often used.

To enter the house, you need to use a special key that owns its number, which acts as an identifier. According to this number, the electronic system recognizes “friend” - “alien” and lets the owner into the house.

Why do you need a key duplicator?

Sometimes it happens that you need to make a copy of the intercom key. The Arduino Intercom Key Duplicator may be needed if one of the keys in the kit was lost, an additional key was required, or the old key failed.

Naturally, in this case, you can use the services of specialized workshops, but you can perform this procedure yourself. This option will be of particular interest to those who understand electronics and have the practice of using modules.

On the Internet, there are many different projects on how to make a copy of the key to the intercom with your own hands using Arduino. The task is not as difficult as it seems at first glance.

You just need to find out the ID number of the original key and assign it to a duplicate. The intercom system will recognize such a key as "own" and will open the door.

The procedure for reading from the key, as well as writing an identifier to it, is performed using only a single-wire 1-wire interface. Thanks to this, the schematic diagram of the future duplicate of the intercom key is quite simple.

Below, all the steps will be considered step by step, through which, in a minimum time and with minimal financial costs, you can independently make a duplicate of your key to the intercom.

How to make an Arduino-based duplicator

To make a duplicator of intercom keys on an Arduino Uno or Nano, you need to carry out separate work with the hardware of the future device, and then with the software.

Hardware

You can create a compact duplicate of the key to the intercom using the Arduino Nano module, which is placed in a case from a non-functioning USB hub. The key in this design is quite compact and easy to use.

A USB cable is used to connect the device to the COM terminal, as well as to supply power to it. A non-latching button should be installed on the key duplicator body, which will be used in cases where it is necessary to switch the “read” / “write” / “restore” modes.

Also, an LED indicator is displayed on the front panel of the case, used to visualize the state of the key (in which of the 3 modes it is), as well as a contact pad that acts as a key reader.

The electronic circuit of the device of the future duplicator is distinguished by its simplicity. It includes a 1-wire data exchange line, to which + 5V is supplied through a transistor, the value of which can be 1 ÷ 4.5 kOhm.

The best option would be the average resistor value of 2.2 kOhm. The mode LED is connected through a limiting resistor of the optimal rating. The mode switch button is connected to pins D2 and GND.

Software part

In the firmware of the device, you can leave the part of the code unchanged that is responsible for the processes of reading and writing data to the dongle via the 1-wire protocol, as well as the part that ensures the operation of the module.

The rest of the code is rewritten for our own needs, using the standard Arduino OneWire library for this. You can write a sketch for programming the Arduino module used for the key duplicator yourself or find a ready-made version on the Internet that you can optimize for yourself.

The created and programmed module based on Arduino will allow:

  1. read from the original key its ID, followed by overwriting into the prepared "blank" of the key;
  2. write down the universal ID that is set in the sketch;
  3. provide protection for accidental ID overwriting with an incorrect value;
  4. restore unreadable keys after an incorrect entry of the identifier;
  5. enter the ID number manually;
  6. support operation without a COM terminal provided that there is a 5 V DC power supply, which is supplied via the USB connector.

How to work with the device

Do-it-yourself intercom key duplicator on Arduino can be used both with and without a COM terminal. To work with the COM terminal, you must first install the appropriate drivers for the Arduino board you are using on your computer.

Any COM port terminal that suits the user best can be used. Before using the terminal, you need to make some of its settings, namely, select a virtual COM port for which the board is defined and the data exchange rate that is recorded in the sketch.

After the device settings are completed, it should be connected to a personal computer and the COM port terminal should be launched. The Arduino module will then automatically reboot. During the download process, the LED indicator will flash several times.

After a few seconds after the download is completed, the device will be ready for operation, the LED indicator will not light in this case, and a message will be displayed in the terminal that the system is ready for use.

The following commands will be available to the user through the terminal:

  • the process of loading into the universal identifier buffer;
  • switching between read and write modes;
  • switching to the mode for manual entry of the ID-identifier;
  • transition to the unreadable key recovery mode;
  • displaying help on the commands used.

Key reading

To make a duplicator of intercom keys on Arduino, you must first copy the ID-identifier from the original key. In order to read the key, you need to attach it to the contact pad of the device.

The LED in this case will blink rapidly, and the readable ID will be displayed on the terminal. The code read from the original key will be temporarily stored in the buffer until it is reloaded with another identifier.

To store one ID-code, 8 bits are used, which are displayed in a six-digit code.

Write key

In order to write the copied identifier to the writable blank of the intercom key, the terminal should be switched to the recording mode using the appropriate command or using the button on the device. The glow of the LED will indicate that the mode has been changed and the device is ready to write the key ID.

After that, you need to attach the writable key to the pad. At this time, the LED will turn off and after a few seconds it will start flashing at a high frequency, which will indicate the progress of the recording process.

Upon completion of the ID overwrite procedure, the device will automatically enter the read mode. After the device has switched to read mode in the terminal, you can see the newly written ID-identifier.

If the operation was successful, it will correspond to the identifier that was previously read from the original intercom key. If the ID code being written was incorrect or a write error occurred, the terminal will display a corresponding message and the write procedure will be canceled.

Thanks to this, the device protects the intercom key from writing incorrect information to it.

Recovery of an unreadable key

To restore an unreadable intercom key, you need to switch the device to the appropriate mode using a special command in the COM terminal or by holding down the button on the front panel of the device. Next, attach the key to the contact pad.

If it is operational and the ID code can be read from it, then this will happen as in the normal reading mode, after which the corresponding 16-digit identifier will be displayed on the terminal. If the key is not readable, then, accordingly, no procedure will be implemented to the end and the code will not be displayed on the terminal.

In this case, you need to hold the key attached to the pad and press the device button. Thanks to this procedure, the universal identifier will be forced to be written, which was previously registered in the sketch.

After the end of the forced write, the device will automatically enter the read mode. In the future, the universal ID-identifier can be replaced with the original code read from the intercom key.

Other operations

Loading the universal ID-code into the buffer. This procedure can be done by executing the appropriate command in the terminal or by rebooting the device if the universal ID was specified in the sketch.

Copying Arduino intercom keys can be done without the original. To do this, it is enough to know its ID-identifier, which is registered in the scratch and used as a universal code.

The device provides the ability to manually enter an ID-identifier. To do this, you need to set the appropriate command in the terminal, after the execution of which you can enter any ID code in 16-digit form.

Conclusion

Above, we discussed the procedure for how, using a conventional Arduino module, you can independently make copies of intercom keys. Now there will be no problem where to make a new key if the old one is lost or accidentally failed.

In addition, having this device, it will be possible to recover unreadable keys, which can be renewed using the Arduino-based device and the original key ID.

Video: A simple duplicator of intercom keys on the Arduino Nano