Overview

On this page you'll find an experimental codec that simulates both PT2272 decoder and PT2262 encoder chips. These two chips are commonly found in many inexpensive garage door openers and are of fixed code type. They provide a configuration word of 12 ternary digits which means that there are 3¹² = 531441 different code combinations.

This is by no means a secure solution since the code transmitted by these chips never changes and all it takes to duplicate one of these remote controllers is to listen for the transmission and then replay it. There are more secure solutions using rolling code techniques where the code changes every time the remote controller transmits. Rolling code solutions are more complex to implement and require constant synchronization between transmitter and receiver.

Schematic

The schematics presented below are based on a PIC 16F628 because both encoder and decoder firmwares were developed on a 16F628 but it shouldn't be hard to port to other PICs. The encoder schematic is on the left and the decoder on the right.

The output pin of the encoder is on RB3/CCP1 pin 9 and the input pin for the decoder is on RB4 pin 10. The signal on these pins is not modulated with any RF carrier. 

• The RF signal is generated by a small FS1000A 433MHz ASK transmitter module connected to the output pin RB3/CCP1.
• And the receiver pin RB4 is connected to a XY-MK-5V ASK receiver.

They can be bought at almost every online shop selling Arduino parts.

PCB

This is an experimental driver software to use in your own projects. It was developed on a white breadboard with lots of wires!

There is no PCB!

Software

The codec contains two modules that can be used independently of each other or together, because they don't share any of the PIC resources. They are separated into 2 files each:

• pt2262.[ch] - PT2262 encoder
• pt2272.[ch] - PT2272 decoder

There are other files that are auxiliary to the codec:

• common.h - FOSC macro
• config.h - eeprom address and data for the transmitter example program
• rs232.[ch] - optional serial routines for the receiver example program
• pt2262_tx.c - optional main transmitter example program
• pt2272_rx.c - optional main receiver example program
• README.txt - a file you should read!

Currently both encoder and decoder modules run with a fixed 10KHz clock rate when the PIC is driven with a 10MHz crystal oscillator.

Binary digits and ternary digits

One thing that distinguishes PT2262 and PT2272 from other remote controller chips like MM53200 is the fact that they don't use binary digits (bits) for the 12 bits configuration word. While on a MM53200 those 12 digits can be 0 or 1, on the PT2262 and PT2272 the configuration digits can be 0, 1 and F (float). Using ternary digits for the configuration word increases the number of possible combinations from 2¹² = 4096 to 3¹² =  531441 as stated above in the overview.

The use of ternary digits means that each digits can not be stored in a single bit, i.e. a single bit is not enough to represent 3 states, just 2. We need to use more than 1 bit for each digit. On the next section is an example of the encoding the ternary digits using nibbles instead of bits!

Encoder PT2262 module

The encoder module simulates a PT2262 IC running with a 10KHz clock. The interface is quite minimalistic having one method to send a transmission and another to check if the previous transmission has ended:

#ifndef PT2262_H_EMITTER
#define PT2262_H_EMITTER
 
// setup timer1, ccp1, pins and interrupt flags
void pt2262_setup(void);
 
// to be invoked on TMR1IF and CCP1IF
void pt2262_isr(void);
 
// start a transmission with the nibbles pointed by address and data
// it will lock if the previous transmission is in progress
// - address should contain 3 bytes, each nibble with value 0..2
// - data should contain 3 bytes, each nibble with value 0..2
void pt2262_tx(unsigned char *address, unsigned char *data);
 
// is it still transmitting?
bit pt2262_busy(void);
 
#endif

The transmission function is pt2262_tx and it accepts the 12 ternary digits to be sent. These 12 digits divide themselves in 6 for the address and 6 for the data. So both address and data should be arrays of 3 bytes and each byte represents 2 ternary digits, i.e. one ternary digit on each nibble. Here's an example:

To encode the 6 ternary digits "1 0 F 1 F 0" of address the array should have the following 3 bytes: [0x10, 0x21, 0x20] where 'F' is represented by the value 2, '1' is represented by the value 1 and '0' by 0. Yes there are some unused bits on every nibble but this a simple solution that works and doesn't complicate the code that much.

On the transmitter main example program both address and data are being read from the EEPROM. This is not mandatory but since the address part is usually fixed I thought of providing it as an example. The data can, of course, be defined based on the value of several push buttons connected to the PIC. 

The output of the encoder module can be seen on these screenshots. On the left is a single code word and on the right is the same code word zoomed in.

Decoder PT2272 module 

The decoder module simulates a PT2272 IC also running with a 10KHz clock. Its interface, shown below, is also minimalistic:

#ifndef PT2272_H_RECEIVER
#define PT2272_H_RECEIVER

// setup IoC, timerX
void pt2272_setup(void);

// to be invoked on RBIF
void pt2272_isr(void);

// returns the last known message
// address will contain 3 bytes, each nibble with value 0..2
// data will contain 3 bytes, each nibble with value 0..2
// returns true if new data is available and false if no new data is available since last read
bit pt2272_rx(unsigned char *address, unsigned char *data);

// returns true if a new message is available
bit pt2272_poll(void);

#endif
 

The 2 important functions are pt2272_poll and pt2272_rx, the former tests if a valid frame has been received and the latter retrieves the 12 ternary digits only when a valid frame has been received. Calling pt2272_rx without a valid frame does nothing and returns false.

Like on the transmitter module, both address and data parameters should be arrays with 3 bytes. The 12 ternary digits received will be placed one per nibble on each array. The main program prints every correctly decoded frames to the serial port.

The output of the receiver example program, on the serial port, is this:

Frequencies and signal clock rate

The signal generated by a PT2262 represents 0, 1 and F as a sequence of pulses:

Published on Monday 2014/10/27, last modified on Tuesday 2014/11/04