- DPL / DCS Information
     - DPL / DCS Introduction
       - Motorola Compensation Alignment
     - DCS Standard Codes Listing
     - DCS Extended and Unusable Codes Listing
     - Additional DCS Information
   - HOME







DPL / DCS Introduction:

This section has background information that applies to a coded squelch system which is used by every major radio manufacturer. Because it is not just Motorola specific (i.e. only about Motorola products), I will use the generic Digital Coded Squelch (DCS) term instead of the Motorola trade mark Digital Private Line (DPL). DCS and DPL are functionally the same. See the PL / CTCSS page for additional information on coded squelch systems.

The Syntor X has specific information on it's PL/DPL.

DCS is a digital squelch scheme which is sent by a transmitter to control the squelch opening of a receiver. DCS is designed to work in the "so called" sub-audible portion of the communications audio band below 300 Hz. DCS digital code values are actually Golay {23, 12} codes. The {23, 12} notation tells us it is a 23 bit Golay word with 12 data bits included in the total 23 bits. There is lots of information on Golay {23, 12} on the web, so I will not go into those details here. The important feature of Golay {23, 12} is that software in the receiver can detect and correct up to 3 bit errors from the transmitted signal, just by processing the 23 Golay bits from inside the receiver. Golay codes also have an unusual property. The 23 bit word can have its bits rotated to any new position and it still forms a perfect, but different Golay {23, 12} code word. These are a few of the things that make Golay codes so interesting to mathematicians, which is probably why there is so much information on Golay available.

DCS signals are digital square wave signals where the square wave signal represents '1' and '0' data bits. The sharpness of the edge of a square wave signal is determined by the amount of odd harmonics in the signal. The more strong odd harmonics, the sharper the waveform edge is. Since the harmonics are progressively higher in frequency than the original DCS signal, they are clearly audible above 300 Hz. Since DCS creates audio harmonics well above 300 Hz (i.e. into the audible portion of the band from 300 to 3000 Hz), radios must have good filters to remove the unwanted DCS noise. The DCS Tx filter will change the normally sharp rise and fall edges of the square wave into more rounded shapes when it removes these higher frequency harmonics. It is up to the receiver to be able to recover these rounded signals and accurately decode the digital information from the signal. Some radios will actually create rounded edges with the DCS code synthesizer hardware rather than having to completely rely on the DCS Tx filtering.

DCS also includes an optional reverse burst to quietly close off the receiver squelch at the end of a transmission. This eliminates the receiver "squelch tail" noise burst.

The order which this material is explained in, is (hopefully) designed to reduce the confusion about + and - DCS codes. To accomplish this we will start with simplified DCS code theory. This theory section will assume perfect laboratory conditions. All DCS code transmitters will send perfectly encoded DCS and all receivers will perfectly receive the exact same polarity DCS code. However, in the real world, the polarity is not guaranteed to be the same (more on this later).

A DCS code is a mathematical construct that does not have or recognize any polarity concept when examining the structure of any valid DCS word. In other words, even if you invert the DCS word bits, you still have to deal with the 23 bit result as a positive code. As mentioned above, DCS values are actually Golay {23, 12} values. The DCS 11 check bits are used the exact same way as the Golay 11 check bits, for validating the remaining 12 bits and for bit error correction use. This leaves the 12 Golay data bits (bits 12 through 23). The difference from Golay is DCS values require a fixed "100" bit pattern in the 12th, 13th and 14th bits. This only leaves 9 bits for the familiar DCS code that we program into our radio squelch systems. This means DCS codes are a sub-set of Golay {23, 12} codes. Golay codes with 12 data bits have 4096 possible values. DCS codes with 9 data bits have 512 possible values.

DCS digits are in the octal number base. Each code is made up of 3 octal digits also known as 3 octets. An octet is 3 bits, so 9 bits total divided by 3 bits per octet, makes 3 individual DCS code digits. Each DCS code digit can have a value from 0 to 7 (the maximum number of different values you can put into a 3 bit octet). There are 512 decimal DCS codes total from 000 to 777 octal. If you use a calculator that has both octal and decimal (such as the Windows Calculator in scientific view), you can easily convert these octal 000 to 777 numbers back to decimal (777 octal = 511 decimal). Remember, 000 octal is a valid DCS code. So, if you start counting from 0 and count up to 511 decimal you will find there are 512 decimal values total.

Here is the format of the 23-bit DCS word (the dash and slash characters are just used for formatting to make it easier to read):
 11 Check Bits  - Signature  -  9 Bit DCS Code

 C  C  C  C  C  C  C  C  C  C  C  -  1  0  0  -  D  D  D  /  D  D  D  /  D  D  D

 1  2  3  4  5  6  7  8  9  1  1    1  1  1    1  1  1    1  1  2    2  2  2
                   0  1    2  3  4    5  6  7    8  9  0    1  2  3

A DCS code either is or is not a valid DCS code (there is no gray area). The '100' bit pattern (with a 1 in bit position 12 decimal, a 0 in bit position 13 decimal and a 0 in bit position 14 decimal) is the identifier signature of a 23-bit DCS word. If it does not have this magic '100' bit pattern in exactly this location, it is not a 23-bit DCS word. This '100' bit pattern will be referred too as the 100 signature match.

It turns out, if you perform a circular rotation on all the bits in the entire 23-bit DCS word, you may find more than one valid DCS code in the same 23-bit DCS word. Here is an example of rotating the 23-bit DCS word, starting at the valid DCS code of 023 octal.

11101100011-100-000/010/011 = 023 (valid DCS word)
11110110001-110-000/001/001 - rotate right one bit position, no 100 signature match
11111011000-111-000/000/100 - rotate right one bit position, no 100 signature match
01111101100-011-100/000/010 - rotate right one bit position, no 100 signature match
00111110110-001-110/000/001 - rotate right one bit position, no 100 signature match
10011111011-000-111/000/000 - rotate right one bit position, no 100 signature match
01001111101-100-011/100/000 - rotate right one bit position = 340 (valid DCS word)
00100111110-110-001/110/000 - rotate right one bit position, no 100 signature match
00010011111-011-000/111/000 - rotate right one bit position, no 100 signature match
00001001111-101-100/011/100 - rotate right one bit position, no 100 signature match
00000100111-110-110/001/110 - rotate right one bit position, no 100 signature match
00000010011-111-011/000/111 - rotate right one bit position, no 100 signature match
10000001001-111-101/100/011 - rotate right one bit position, no 100 signature match
11000000100-111-110/110/001 - rotate right one bit position, no 100 signature match
11100000010-011-111/011/000 - rotate right one bit position, no 100 signature match
01110000001-001-111/101/100 - rotate right one bit position, no 100 signature match
00111000000-100-111/110/110 - rotate right one bit position = 766 (valid DCS word)
00011100000-010-011/111/011 - rotate right one bit position, no 100 signature match
10001110000-001-001/111/101 - rotate right one bit position, no 100 signature match
11000111000-000-100/111/110 - rotate right one bit position, no 100 signature match
01100011100-000-010/011/111 - rotate right one bit position, no 100 signature match
10110001110-000-001/001/111 - rotate right one bit position, no 100 signature match
11011000111-000-000/100/111 - rotate right one bit position, no 100 signature match
11101100011-100-000/010/011 - rotate right one bit position = 023 (DCS word) we are back where we started.

In this example, you see the same 23-bit DCS word can produce three different valid DCS codes (023, 340 and 766). The true magic here is the mathematically calculated check bits (11 check bits for each valid 23-bit DCS word) are always completely correct for each of these three different valid DCS codes. This multiple matching code example is not true for all 23-bit DCS words. Some 23-bit DCS words only have a single valid DCS code and others can have up to 6 different DCS codes. It all depends on the specific bit pattern in each of the individual 512 decimal 23-bit DCS words.

An alternative way of thinking about these multiple codes coexisting in the same 23-bit DCS word data stream is to think of the 23 bits as simply being shifted in time. As in, each bit takes some amount of time to send and you are simply beginning your look at the 23 bits starting at different times. So, each individual rotation of the 23 bits can be viewed as an individual incremental time window on the repeated 23-bit DCS word data stream. This concept can be helpful because of the way the receiver works with 23-bit DCS words.

A 23-bit DCS word is transmitted as a continuously repeating 23 bit stream of asynchronous serial bits. This brings up the obvious question, "How do you know which bit was sent first?". The answer is there is absolutely no way to tell. The receiver just has to jump into the 23-bit DCS word bit stream, get 23 bits and rotate them around until it finds the 100 signature match. When it finds a 100 signature match and its DCS code is not the one it is looking for, it can just keep rotating the 23 bit DCS word and check for all possible valid DCS codes in that bit stream. Of course it would stop rotating the 23-bit DCS word after 22 rotations. If the receiver cannot find the DCS code it was looking for, then it will not open the receiver squelch.

Again, a DCS 23 bit word is transmitted as a continuously repeating 23-bit stream of asynchronous serial bits. This means there is no explicit signal to synchronize the bit timing between the transmitter and receiver. Some kind of synchronization is required so the receiver can distinguish one bit from the next bit. Asynchronous protocols accomplish this with a fixed bit timing rate. Since the transmitter and receiver both use the same bit timing rate, then each bit can be sent by the transmitter and successfully decoded by the receiver. For DCS, the bit timing rate is 134.3 Hz.

There is nothing in the DCS math that recognizes or knows about signal inversion. More importantly, there is no way for the transmitter to tell the receiver what the correct polarity is to decode its signal. With these assumed "perfect laboratory conditions" where the transmitter and receiver both have the same signal polarity, what we send is what we get. If we Tx a 023 DCS code, we will Rx a 023 DCS code, after the receiver rotates the 23 bits around to find it.

Notice that even though we sent a 023 DCS code, we could also receive it as DCS code 340 or DCS code 766 if we wanted to. This brings up the question, "How do we know which code to use?". The only answer is there seems to be an un-enforced agreement to only use one DCS code when there are multiple possible DCS codes (more on this later). The other matching DCS codes (like 340 or 766) are still there, they are just ignored. This agreement only applies to the so called "standard" set of 83 DCS codes used by the communications industry.

This is all for the "perfect laboratory conditions", now we will dive into the real world. In the real world there is no guarantee that a transmitter and receiver will have the same signal polarity. Unless you are using the exact same manufacturer and model of radios for Tx and Rx, there just might be an unavoidable polarity inversion between them. Let's take a look at what happens when the equipment inverts the DCS 23 bit word polarity:

11101100011-100-000/010/011 = 023 (valid DCS word)
00010011100-011-111/101/100 - inverted 023 DCS word, no 100 signature match in this inverted signal

You can see the signal inversion of the 023 valid DCS word turned the 100 signature into an invalid 011 bit pattern. This is where the mathematical properties of DCS codes have a surprise waiting. If you rotate the inverted 23-bit DCS word (as in the above example) you will find these three totally different valid DCS codes hiding inside the inverted signal.

11101100000-100-111/000/111 = 707 (inverted 023 word rotated to the first 100 signature match)
10000010011-100-011/111/101 = 375 (inverted 023 word rotated to the second 100 signature match)
00011111101-100-000/100/111 = 047 (inverted 023 word rotated to the third 100 signature match)

This means that any receiver that inverts the DCS polarity can receive the original 023 DCS code as DCS codes 707, 375 or 047. So, if the station at the transmitter tells you it is transmitting DCS code 023 and you program your receiver (which inverts the Tx DCS code) to Rx DCS code 023, it will not match and your squelch will not open. This is where the fiction of positive and negative polarity DCS codes comes about. I called it a fiction because the mathematical model is very clear and has nothing to do with positive or negative polarity. What the positive and negative polarity really means is applying signal inversion to the DCS code. However, when you invert a valid DCS code with the 100 signature match, it always turns it into an invalid 011 signature mismatch (this means any valid 23-bit DCS word is never valid when it is inverted). However, if you start rotating this inverted 23-bit DCS word, you can find other valid DCS codes. The same as before, the 11 decimal check bits are mathematically correct whenever the 100 signature match is found and any particular 23-bit DCS word may have from one to six valid DCS codes inside it. However, the real solution is to re-invert the DCS signal inside the receiver which will recover the original signal polarity DCS code that the transmitter sent (more below).

The most important point is too recognize that the DCS codes are all treated the same way. The math behind the DCS code has no idea if your signal polarity was inverted or not inverted. It only cares about the 100 signature match and having the 11 decimal check bits come out correctly for the received DCS code. We are the ones who care about the signal inversion. When we are told to use a certain DCS code for our radio communications, we want to be able to make that DCS code work correctly.

The typical notation for normal positive signal polarity is +023 and -023 is inverted signal polarity. The "-" in front of the DCS code means the radio hardware has inverted the 23-bit DCS word signal polarity. This inversion means each 1 bit is turned into a zero bit and each zero bit is turned into a 1 bit.

In the above example where your receiver signal polarity is opposite the transmitter signal polarity, you can simply tell your receiver to invert the DCS signal polarity before using it. This inverts the inverted signal, returning it to normal polarity. This is the most common use for DCS polarity. How many people know, remember or even understand that DCS codes 047, 375 or 707 could be used to Rx an inverted 023 DCS code. The answer is you do not have to know. If someone tells you they are using the 023 DCS code to transmit, then you must try both +023 and -023 in your receiver to find out which one will work.

The transmitter also uses DCS signal inversion. When you setup your transmitter DCS code to work with other radios that are already using a DCS code (like 023), it is not practical to make everyone else change their Rx DCS code polarity to match your transmitter. Again, you must try both +023 and -023 transmit DCS codes to find out which polarity works with all the other already programmed receivers.

The problem is there is no way to tell how each and every particular transmitter sends a FM modulated signal. There is also no way to tell how each and every particular receiver FM discriminator circuit decodes the polarity of the received signal. Being able to apply inversion to the transmitted signal and/or inversion to the received signal is the solution to getting a system of different radios to successfully use the same DCS code.

The effect of the so-called DCS polarity is you have what looks like a set of 512 decimal positive codes (+000 to +777 octal) and what looks like a set of 512 decimal negative codes (-000 to -777 octal). In reality this is an illusion because there are really only 512 total DCS codes (000 to 777 octal). In the above example it was pointed out that an inverted 023 DCS code could be received as a 047, 375 or 707 DCS code. All of these codes are positive DCS codes and it is only the inversion of the signal voltages that makes the difference. So, there is not really a positive and negative set of DCS codes. The - simply indicates that the 23 bit DCS word signal has been inverted by your radio's circuitry and inverted DCS signals produce a different set of codes.

There are four unique DCS codes that all match each other when their 23-bit DCS word is rotated, that do not have any inverted polarity matches. They are 112, 250, 505 and 512. When these are inverted, there is no possible 100 signature match in the entire 23-bit DCS word (more on this later).

Lets say we have a receiver that can display the actual DCS code being received. Since there is no way to tell if the receiver polarity matches the transmitter polarity, it means the transmitter could be sending one of two possible codes (except for the four unique 112, 250, 505 and 512 DCS codes which have no inverted match). My receiver DCS display could say +023 or -047 for the same Tx DCS code. If our receiver polarity matches the transmitter polarity, it means the transmitter is sending +023 (without inversion) or -047 (with inversion). However, if our receiver polarity is opposite the transmitter polarity, then it means the transmitter is sending +047 (without inversion) or -023 (with inversion). Since our display told us +023 and -047, we know these Rx DCS codes will work with that transmitter. The real uncertainty here is we do not know which polarity the transmitter has in relation to our receiver, so we do not know exactly which code the transmitter is using. One way to know is if the transmitter and receiver are both the same brand and model of radio (then they match). The other way to know is ask whoever programmed the transmitter which DCS code they are using.

The following is a table of all the possible DCS polarity/code combinations that can se sent or received as a DCS code related to 023:

 Tx same as Rx +023 023 023 +023
 Tx same as Rx +023 023 023 -047
 Tx same as Rx -047 023 023 +023
 Tx same as Rx -047 023 023 -047

 Tx same as Rx -023 047 047 -023
 Tx same as Rx -023 047 047 +047
 Tx same as Rx +047 047 047 -023
 Tx same as Rx +047 047 047 +047

 Tx opposite Rx +023 023 047 -023
 Tx opposite Rx +023 023 047 +047
 Tx opposite Rx -047 023 047 -023
 Tx opposite Rx -047 023 047 +047

 Tx opposite Rx -023 047 023 +023
 Tx opposite Rx -023 047 023 -047
 Tx opposite Rx +047 047 023 +023
 Tx opposite Rx +047 047 023 -047

In reality, the 047 code would never be programmed if you know 023 is the DCS code being used by the other stations. It is included in the example for information only. Remember that DCS codes 023, 340 and 766 are all interchangeable. Also DCS codes 047, 375 or 707 are all interchangeable. However, we have ignored DCS codes 340, 766, 375 and 707 because they are just synonyms for other 23-bit DCS words. This means 023 represents all three of its DCS codes and 047 represents all three of its DCS codes. I am calling this lumping together of related groups of DCS codes, DCS code groups (more on this later).

The example in the table above is very messy. This messy information was shown so you can understand what is happening with DCS codes and signal polarities. For example, if you did not understand all the information in the table above then you would be confused by the table below where -023 is sent as 047. However, in real life all this is just too much information to deal with. Here is a table that shows the real world common usage for non-inverting and inverting DCS codes:

 Tx same as Rx +023 023 023 +023

 Tx same as Rx -023 047 047 -023

 Tx opposite Rx +023 023 047 -023

 Tx opposite Rx -023 047 023 +023

Notice how the radio user does not really care about the SENT AS or RECEIVED AS information. All the radio user needs to know is the correct DCS code to use and how to program +/- to correct the signal polarity.

Using the above example, the only reason for programming Tx -023 is when other brands or models of radio receivers in your communications system have inverted DCS signal polarity from your radios transmit polarity. You just need to try both +023 and -023 Tx until you find out which one works with all the other radios in the system..

There is a certain way that 23 bit DCS words are sent. It is called Non Return Zero (NRZ) bit coding. Simply put, it means if you send three 1 values in a row, it keeps the output at a one value for the bit timing period of all three 1 bits. If three 0 values were sent, it keeps the output at a zero value for the bit timing period of all three 0 bits. There is lots of information on the web about NRZ coding.

Another interesting effect of the math behind DCS and NRZ coding, is all 23-bit DCS words fall into three categories. Each 23-bit DCS word has either 8, 12 or 16 transitions from zero to one and one to zero in each 23 bit cycle.

Keep in mind; the whole reason for using DCS is so you can have a unique code to use in your particular radio system. Because of these multiple decode hits from one single transmitted code, it is simply not possible to use all 512 decimal DCS codes and keep them unique (there are 177 decimal unique DCS code groups). However, by reducing the number of DCS codes used to only one DCS code from each group, it is possible to come up with a usable set of DCS code groups (i.e. DCS codes may be considered to be "unique" if you simply ignore and do not use the duplicate codes). Most manufactures only use 83 to 112 decimal of the 177 decimal unique DCS code groups. There is no enforced "standard" on which DCS codes should be used, so everyone uses however many codes they want, but everyone seems to use the exact same basic set of 83 DCS codes. There are 177 decimal unique DCS code groups (synchronizing to the 100 signature match bit pattern in each shifted DCS word mentioned before). So, most of the 177 decimal groups has multiple unique individual DCS codes that belong to each group, but any extra DCS codes in each group are ignored (a single DCS code is used to represent all the DCS codes in that group).

If we lump all the matching DCS codes together into DCS code groups, we are left with only 177 decimal unique DCS code groups. Each DCS code group has its own unique DCS code that identifies the entire group, while the other DCS codes in a DCS code group are ignored and never used. This a big step down from 512 decimal DCS codes. 177 decimal is the best possible outcome since DCS was created without any way of identifying the beginning of each DCS word. Still 177 decimal sounds like a fair amount. However, some DCS codes do not work well in the real world. Some of them can false CTCSS detectors and others are not easy to reliably decode. Sometimes these decoding difficulties are created by the actual decoding hardware/firmware inside the receiver. So, we take another big step down to get a total of 83 so called "standard" industry DCS codes. These so called "standard" DCS codes should work with any DCS capable radio and should not cause any problems for CTCSS tone detectors that are also used on the same radio frequency. All of the so called "standard" 83 DCS codes only have 8 or 12 signal level transitions in each 23-bit DCS word.

You also should note that an inverted 23-bit DCS word is not the same thing as an inverted 9-bit DCS code. For example; if you logically invert just the 9-bit DCS code bits for 023 octal, you will get DCS code 754 octal. However, the DCS code for 754 has nothing to do with DCS code 023 (as shown in previous examples above). We have no use at all for inverted 9-bit DCS codes, we only have uses for inverted 23-bit DCS words.

DCS Timing

The above timing chart shows the timing relationships. There is a vertical line at the beginning and at the end of the timing diagram. The 134.3 Hz square wave is what the bit timing is based on and also happens to be to the DCS reverse burst signal. The reverse burst signal is only sent for a short time when the transmitter PTT is released. The 67.15 Hz square wave is what you would get sending a repeating 101010.... bit pattern in NRZ coding. This is not a valid DCS code and was only shown to illustrate basic NRZ coding of continuous 1 and 0 bits. If you count, you can find 12 one bits and 11 zero bits in the repeating pattern sample. The +023 waveform is the actual DCS word for the 023 code. Bit positions 1, 11, 15 and 23 are marked. The position of the 11 check bits, 3 '100' bits and 9 DCS code bits are marked. The +023 waveform simply repeats constantly (i.e. after bit 23, just loop back to the first bit and start all over again). You can count the eight 0 to 1 and 1 to 0 transitions in the 023 waveform. You can also see that there is a maximum of six consecutive 0 values (starting at bit position 13) and a maximum of five consecutive 1 values (starting at bit position 22), so the longest continuous interval without any signal transition for the receiver to possibly re-synchronize the asynchronous timing on is six cycles at 134.3 Hz. The binary coding bit values for +023 is shown at the bottom of the chart. Because this is just a drawing, all the square wave edges are nice and sharp, not like the DCS signals with rounded edges produced by Tx filtering/generation.

In summary, if a scanning receiver finds a frequency with an active Tx DCS code, it has no way to tell where it is in the DCS bit stream (i.e. it could jump in when bit 17 was being sent, or any other bit). There is no special start or stop synchronizing code, just a repeating bit stream. This is why synchronizing to the 100 signature match bit pattern is the only way the receiver has to make sense of the DCS bit pattern and pull out any valid DCS codes. If there was a special synchronizing code just to identify the starting or ending bits added to the DCS word, then all 512 DCS codes could be decoded as unique codes, but it was never done this way. This inability to synchronize to the exact start of each DCS word being sent is why there are so many codes that match each other at the receiving end. As mentioned before, there are 177 groups of unique DCS groups. Each group consists of multiple individual DCS codes. Not all 177 groups are actually usable, which is why there is a so called "standard" set of 83 DCS codes.

The actual DCS code is sent in the reverse order shown above. We humans are used to writing our numbers from larger to smaller. As in we write ninety eight as 98, not as 89. It would have been confusing to write all the DCS binary values backwards the way the radio sends them, however this is how they are actually sent over the air. So, the DCS 023 example '11101100011-100-000/010/011' is actually sent as '110/010/000-001-11000110111'.

Phase modulated radios may have trouble sending DCS (i.e. Tx) because the 23 bit DCS code is a low speed digital signal. In general, phase modulators are not optimal for this type of modulation. All of the Motorola mobile radios on this web site use true FM modulation, which is optimal. However, the Tx compensation control must be correctly adjusted to send good DCS signals. If you have worked on or replaced parts of your Motorola radio that affect the FM modulator hardware or its DCS input signal path, then you had better check/adjust the compensation alignment if you plan on using DCS.

The timing of the entire 23-bit DCS word consists of 23 individual cycles of a 134.3 Hz signal. Just divide 1 by 134.3 cycles/second (this gives seconds/cycle) and multiply by 23 cycles to find out how many tenths of a second it takes to send a DCS code. You will get about .17125 seconds per 23-bit DCS word. This means you can almost, but not quite squeeze six 23-bit DCS words into each second.

Below is a list of all 83 standard DCS code groups. In each group, the first line is a list of the matching normal polarity DCS codes. The second line below it is the DCS codes from the matching inverted polarity 23-bit DCS word. The DCS code groups are separated by dashed lines. This is a complete listing of all the matching DCS codes for each group, including the ones that are normally ignored and not used. The bold DCS codes show in blue are the DCS codes that normally get used from the so called "standard" set of 83 codes. Just a reminder, even though the ignored codes are shown, it does not mean your radio's DCS system can encode or decode them correctly (just use the standard codes). However, mathematically the waveforms produced by each individual group are all related through shifting for the "100" bit pattern decode and signal inversion.

All of the statistics in this paragraph are decimal values (do not confuse any of these numbers with octal values). Out of the 83 unique so called "standard" codes, 179 individual DCS words are related codes that are not used. It takes 262 codes (83 + 179) just to get 83 unique so called "standard" codes. Keep in mind that there is no master list for or enforcement of the so called "standard" codes, so you may still see different unique codes used by different manufacturers, possibly in older radios.

Here is the list of the so called "standard" DCS codes:
+023, +340, +766
-047, -375, -707
-176, -244, -417
+026, +566
-237, -464, -642, -772
+031, +374, +643
-037, -560, -627
-520, -771
+043, +355
-222, -445, -457, -575
+047, +375, +707
-023, -340, -766
+051, +771, +520
+054, +405, +675
-133, -413, -620
+065, +301
-271, -427, -510, -762
+071, +603, +717, +746
-147, -303, -306, -761
+072, +470, +701
-245, -370, -554
+073, +640
-224, -313, -506, -574
+074, +360, +721
-142, -174, -270
+114, +327, +615
-136, -502, -712
+115, +534, +674
-152, -366, -415
+060, +116, +737
-076, -203, -754
+125, +173
-107, -365
+131, +572, +702
-130, -364, -641
+132, +605, +634, +714
-317, -546, -614, -751
+134, +273
-223, -350, -475, -750
+143, +333
-127, -412, -441, -711
+152, +366, +415
-115, -534, -674
+155, +233, +660
-447, -473, -474, -731, -744
+156, +517, +741
-171, -265, -426
+162, +416, +553
-157, -322, -503
+165, +354
-236, -251, -704, -742
+057, +172
+142, +174, +270
-074, -360, -721
+135, +205, +610
-213, -263, -736
+223, +350, +475, +750
-134, -273
+104, +226, +557
-117, -411, -756
+243, +267, +342
-351, -353, -435
+176, +244, +417
+245, +370, +554
-072, -470, -701
+236, +251, +704, +742
-165, -354
+227, +261, +567
-164, -207, -732
+213, +263, +736
-135, -205, -610
+171, +265, +426
-156, -517, -741
+271, +427, +510, +762
-065, -301
+147, +303, +306, +761
-603, -071, -717, -746
+311, +330, +456, +561
-344, -471, -664, -715
+315, +321, +673
-234, -423, -563, -621, -713
+331, +372, +507
-056, -465, -656
+324, +343, +570
-161, -345, -532
+346, +616, +635, +724
-254, -314, -612, -706
+351, +353, +435
-243, -267, -342
+130, +364, +641
-131, -572, -702
+107, +365
+217, +371, +453, +530
-066, -734
+117, +411, +756
-104, -226, -557
+127, +412, +441, +711
-143, -333
+133, +413, +620
-054, -405, -675
+234, +423, +563, +621, +713
-315, -321, -673
+262, +316, +431, +730
-235, -611, -671, -723
+276, +326, +432
-067, -516, -720
+222, +445, +457, +575
-043, -355
+237, +464, +642, +772
-026, -566
+056, +465, +656
-331, -372, -507
+144, +466, +666
-363, -436, -443, -444, -662
+157, +322, +503
-416, -553
+224, +313, +506, +574
-073, -640
+067, +516, +720
-276, -326, -432
+161, +345, +532
-324, +343, -570
+317, +546, +614, +751
-132, -605, -634, -714
+307, +362, +565
-150, -256, -703
+153, +606, +630
-231, -504, -631, -636, -745
+254, +314, +612, +706
-346, -616, -635, -724
+075, +501, +624
-123, -632, -657
+037, +560, +627
-374, -643
+231, +504, +631, +636, +745
-153, -606, -630
+123, +632, +657
-624, -501, -075
+163, +460, +607, +654
-312, -515, -663, -743
+363, +436, +443, +444, +662
-144, -466, -666
+344, +471, +664, +715
-311, -330, -456, -561
+150, +256, +703
-307, -362, -565
+136, +502, +712
-327, -615
+235, +671, +611, +723
-262, -316, -431, -730
+447, +473, +474, +731, +744
-155, -233, -660
+164, +207, +732
-227, -261, -567
+066, +734
-217, -371, -453, -530
+312, +515, +663, +743
-163, -460, -607, -654
+076, +203, +754
-060, -116, -737

The one anomaly in the standard set of codes, is the DCS group with +172 and -036 is used, but the inverted DCS group with -172 and +036 is not used in the standard set.

Below are the remaining DCS code groups that are not part of the so called "standard" set of 83 code groups above. Some of them are used by different manufacturers (i.e. the encode and decode hardware they make will work with their selected extended DCS codes). The maximum number of groups, from the 177 total groups, that are being used at this time is 112 (this includes the 83 standard DCS codes). The remaining DCS codes appear to be unusable, even by the more adventurous manufacturers.

The matching DCS codes +112, +250, +505 and +512 are unusual as they have no inverted polarity matches at all. If you invert any of these DCS codes, there is no 100 signature match bit pattern produced. I suspect this may have something to do with why the group with these four particular codes were never used.

All of the statistics in this paragraph are decimal values (do not confuse any of these numbers with octal values). Out of the 94 total non-standard codes, 156 are related codes that can not be used since they are not unique. It takes 250 codes (94 + 156) just to get 94 unique non-standard codes. However, there is no "standard" to determine which unique codes to use. I do not have any lists of extended DCS codes (i.e. beyond the standard 83 codes) that are used by different manufacturers (so they are not marked in bold blue like the list above), however there is no point to using more than one code per related group. The DCS codes with 16 NRZ transitions are marked in bold red. The anomalous -172 and +036 codes that were left out of the so called "standard" set are marked in bold blue since the common code for them has already been determined.

Here is the list of non-standard DCS codes:
+000, +352
-705, -257
+001, +476, +760
+002, +522, +540
+003, +100
-113, -573
+004, +300, +334
-347, -434, -776
+005, +044, +400
-021, -277, -402
+007, +670
-214, -310, -377, -437
+010, +033, +600
-463, -637, -775
+011, +401, +531, +625
-651, -677
+012, +215, +320
+013, +063, +700
-376, -617, -763
+014, +450, +500, +544
-646, -665
+015, +740, +747
-141, -177, -541
+016, +154, +206
-357, -477, -774
+017, +200
-050, -167
+020, +170, +230, +601
-166, -773
+021, +277, +402
+022, +264, +461, +613
-576, -722
+024, +120, +260
+027, +201, +242
+030, +055
-527, -764
+034, +103, +140, +410
-336, -770
+035, +124, +403
+036, +137
-057, -172
+040, +052, +404
+041, +111, +451, +514, +602
+042, +160, +216, +341
-361, -373
+045, +240, +305, +543
-716, -727
+046, +202, +210, +421, +644
+050, +167
-017, -200
-452, -524, -765

+061, +211, +232, +650
-537, -735
+062, +070, +101, +407
-367, -676
+064, +151, +440, +406
-555, -571
-001, -476, -760
+102, +121, +323, +604
-547, -757
+105, +204, +247, +420, +710
+106, +221, +241, +304, +424
+110, +126, +302, +430
-752, -755
+112, +250, +505, +512
No Inverted Signal Match
+113, +573
-003, -100
+122, +535
-225, -536

+141, +177, +541
-015, -740, -747
+145, +525
-274, -652

+146, +220, +414, +422, +442, +622
-633, -667
+166, +773
-020, -170, -230, -601
-005, -044, -400
+212, +253
-356, -521

+214, +310, +377, +437
-007, -670
+225, +536
-122, -535

+246, +542, +653
-523, -647, -726

+252, +661
-462, -472, -623, -725

+255, +425
-511, -446, -467, -672

+257, +705
-000, -352
+266, +655
-454, -513, -545, -564

-027, -201, -242
+274, +652
-145, -525

-035, -124, -403
+325, +550, +626
-526, -562, -645

+332, +433, +552
-455, -533, -551

-105, -204, -247, -420, -710
+336, +770
-034, -103, -140, -410
-040, -052, -404
+347, +434, +776
-004, -300, -334
+356, +521
-212, -253

+357, +477, +774
-016, -154, -206
+361, +373
-042, -160, -216, -341
+367, +676
-062, -070, -101, -407
+376, +617, +763
-013, -063-700,
+446, +467, +511, +672
-255, -425

+452, +524, +765

+454, +545, +513, +564
-655, -266

+455, +533, +551
-332, -433, -552

+462, +472, +623, +725
-252, -661

+463, +637, +775
-010, -033, -600
+523, +647, +726
-246, -542, -653

+526, +562, +645
-325, -550, -626

+527, +764
-030, -055
+537, +735
-061, -211, -232, -650
+547, +757
-102, -121, -323, -604
+555, +571
-064, -151, -406, -440
-046, -202, -210, -421, -644
+576, +722
-022, -264, -461, -613
-012, -215, -320
+633, +667
-146, -220, -414, -422, -442, -622,
+646, +665
-014, -450, -500, -544,
+651, +677
-011, -401, -531, -625,
+716, +727
-045, -240, -305-543,
-106, -221, -241, -304, -424
+752, +755
-110, -126, -302, -430
-024, -120, -260
-041, -111, -451, -514, -602
-002, -522, -540

Both polarities of all 512 individual DCS codes are represented in the two above listings, except for codes -112, -250, -505 and -512 which are not valid/usable DCS codes in their inverted form. To keep things straight, remember that the actual DCS code is an octal number. These can easily be converted into binary by converting each of the octal digits into binary and putting all of them of them together. Most calculator programs will also convert from base 8 (octal) to base 10 (decimal). There are 512 (decimal) individual DCS codes total, but DCS code +512 (octal) converts to 330 (decimal). DCS code +777 (octal) converts to 511 (decimal). Since the first DCS code started at +000 (octal), that makes 512 (decimal) DCS codes total.

Additional DCS Information:

This is just additional assorted DCS information.

DCS error correction:

The 23 bit DCS word is actually a sub-set of the 23 bit Golay codes. The reason DCS is a sub-set is because DCS only has 9 data bits with 3 extra fixed bits (the 100 signature match), which makes 12 data bits total including the fixed 100 (9 bit DCS allows 512 decimal different values). Golay codes use all 12 data bits (12 data bits allow up to 4096 decimal different values). A valuable property of Golay codes is errors in the 23 bit code can be detected and some can be corrected. Up to 3 error bits in a 23 bit Golay word can be detected and corrected in Golay codes (including the DCS sub-set codes). Error correction of received 23 bit DCS is not required and its use is strictly optional. However, there is an interesting property of Golay code error corrections. The following is an example:

11101100011100000010011 - 23 bit Golay code for DCS 023
11100000011100000010000 - DCS 023 code mangled between transmission and reception
00001100000000000000011 - 4 bit error total from transmitted word (4 bits are different in the received word)

11100000011100000010000 - incorrectly received word
11110001001100000010000 - DCS 020 value
00010001010000000000000 - 3 bit error total from incorrect received word and DCS 020 (this fits the 3 bit total error Golay rule)

The above received code should not be correctable because Golay can only correct 3 bit errors in a 23 bit word and the original DCS 023 code has 4 bit errors. However, DCS 020 with a 3 bit error correction matches the mangled received code. So, even though the received Golay code is not correctable back to DCS 023, it is correctable to a different valid DCS 020 code. Testing the received mangled Golay code for the number of bit errors will still identify only 3 bit errors because of the nearby (within 3 bits total error correction) matching valid code.

Here is some test data results for false decodes with 4 to 6 bit errors per 23 bit DCS word. Each error is caused by the error correction returning the wrong DCS code (all 512 DCS codes were tested). In addition, all codes tested have at least 1 bit error: The purpose of this test is not to imply you can correct more than 3 errors per 23 bit DCS code word (you cannot), its purpose is to explore what can happen when DCS codes with bit error rates that are unknown to the receiver are run through error correction.

1 bit Corrected 2 bits Corrected 3 bits Corrected Overall Errors
 up to 3 error bits 0% errors 0% errors 0% errors 0% errors
 up to 4 error bits 0% errors 0% errors 68.2% errors 66.0% errors
 up to 5 error bits 0% errors 94.5% errors 91.9% errors 91.4% errors
 up to 6 error bits 99.9% errors 99.9% errors 99.9% errors 99.9% errors

The vertical left side of the table has the maximum number of bit errors in each individual received DCS code. The error correction program does not know exactly how many errors there are in each DCS code, but we know because the program that created the bit errors tells us how many it created. The error correction program does tell us how many bit errors it found and corrected. This information is across the top of the table as number of bits corrected. Inside the table matrix, it tells us how many of the error corrections were wrong (see the above example of 023 being corrected into 020). So, 0% errors means all error corrections were perfect. For example; "up to 4 error bits" sent can cause 68.2% of all "3 bit error corrections" to fail and return the wrong DCS code. All 512 decimal possible DCS codes were tested, so this means 68.2% of 512 DCS codes total failed in error correction when 4 of their 23 bits had errors induced in them. The Overall Errors are just the cumulative percentage of total errors for all the DCS words that were processed through error correction at each error bit level (3, 4, 5 and 6). For example; this tells us that when up to 4 error bits are present that 68.2% of the three bit error corrections failed, but when you include the totals of 1 bit and 2 bit successful corrections into the Overall Errors column, only 66% total of all the codes tested failed error correction.

The test used multiple permutations of bit errors. The test processed 512 DCS codes through multiple bit error patterns for a total of 3,295,407,616 variations. This test depends entirely on the algorithms used, so your actual results may vary, but these are a good general guide line. Using perfect knowledge of exactly what the original 23 bit DCS code word was (a radio receiver can not posses this knowledge), you can see that up to 3 real bit errors per 23 DCS bits gives a perfect error correction accuracy with 0% errors. A bit error rate of 4 makes the 3 bit error correction about 2/3 unreliable, while a bit error rate of 5 makes 2 and 3 bit corrections unreliable and you can kiss accuracy goodbye when the bit error rate hits 6 bits per word. The table does not show it, but there were no zero bit error corrections at all. So, even a 6 bit error rate could not create any DCS codes that could pass for another DCS code without any error correction. All of the errors were corrected into the wrong valid 23 bit DCS code. So, none of the bit corrections produced pure garbage error results.

The conclusion is Golay/DCS bit error correction works, but error correction can lie to us and return the wrong result. The Golay codes are working properly according to their mathematical model. It is just that the mathematical model can be a little too flexible for highly corrupted codes. The problem really occurs because the transmitter and receiver have a noisy/bad connection, causing the receiver to get a very bad 4 bit per 23 bit word error rate or worse. Keep in mind if the receiver is getting this kind of high DCS bit error rate, it is having problems. These problems are usually things like poor signal to noise ratio, burst noise, heavy multi path, poor filtering of the Tx voice audio (i.e. allowing non-DCS voice low frequencies into the Rx DCS decoder) or direct interference on the Rx frequency. So, a DCS signal that needs 3 bit error correction just to work is very marginal to begin with.

I tested the hypothesis that the set of 83 standard DCS codes would only return non-standard DCS codes after error correction and found it to be false (this myth is busted). It only takes a 4 bit error rate with a 3 bit error correction to come up with lots of incorrect standard DCS codes (actually out of all the 4 bit error rate 3 bit error correction tests on standard codes, 48.6 % of them turned a standard DCS code into an incorrect standard DCS code). So, a standard DCS code can very easily turn into another incorrect standard DCS code when the bit error rate gets to 4 or higher. I wanted to test this partly because I have seen information on the web that suggests the 83 standard codes have some kind of special properties to avoid wrong codes. This supposed property is obviously not true for error correction. I also tested to see if any 4 bit error rate DCS codes would return another DCS code from its own group. This never occurred in 4 bit error rate testing. However, at the 5 bit error rate these types of group related corrections started to appear. It lowered the overall errors up to 5 error bits tested from the above table to 90.9% (a .5% decrease) and lowered the 3 bits corrected errors to 90.6% (a 1.3% decrease). The very small percentage decrease makes it obvious that as a rule, you cannot rely on bad error corrections to pick another DCS group from the same original code group (i.e. as in DCS 023 with 5 bit errors correcting to DCS 340 or DCS 766 would be a very, very rare occurrence).

Here is combined test data that counts all returns to another code from the same DCS code group as correct (i.e. not an error) and also counts any error correction result that is not a DCS code with the '100' signature match as correct (any 23 bits without a '100' signature match cannot be decoded as a DCS code and it cannot open the squelch like a wrong code could, it is not really a match):

1 bit Corrected 2 bits Corrected 3 bits Corrected Overall Errors
 up to 4 error bits 0% errors 0% errors 67.6% errors 65.4% errors
 up to 5 error bits 0% errors 93.6% errors 89.8% errors 90.1% errors

When compared with the other table above, the data here tells us the chance of getting an invalid DCS code that the decoder will reject (preventing any false squelch opening) or the chance of getting a correction to another valid DCS code from the exact same DCS group, is not very likely at all.

On the other hand, noise induced DCS reception bit errors should never remain exactly constant from one 23 bit word to the next 23 bit word and DCS does nothing except constantly retransmit/receive the exact same DCS code over and over again. This implies noise induced DCS error corrections returning the wrong DCS code, should only have a short lived effect on the radio receiver squelch, if it has any noticeable effect at all.

The hardware/firmware that decodes the DCS bit stream has a big effect on Rx noise resistance. Some designs are better than others at picking out and faithfully reconstructing the 23 DCS bits. After all, the ideal situation is to receive without errors rather than trying to rely on software error correction.

For the most part, when DCS codes are used without any error correction, the eleven check bits actually become a fairly secure data based filter to screen out noise induced false DCS code matches. However, the receiver will have to be able to recover every single one of the 23 DCS bits without any errors to work. DCS codes using 1 and 2 bit error correction are not as likely to report false DCS codes. Most manufactures do not even mention DCS error correction at all, so there is no reason to expect anyone actually uses it unless they say they do. Still, it is interesting that Golay/DCS allows detection of some errors and can even reconstruct some lost data.

Here is a simple comparison analogy. If DCS codes worked like a normal serial modem, then you would have a start bit, 9 data bits and a stop bit, for 11 bits total. You could not have any way of detecting any errors in the 9 data bits. You would just take whatever you found as is. This means any errors in the 9 bit field would create bogus DCS codes at your receiver. One of these bogus codes originating from a different code than the one you programmed could end up looking like the code your receiver is programmed for and open your squelch (when it really should not), while the correct DCS code you're looking for will not open your squelch because of the bit errors in the 9 bit DCS field. You could add a parity check bit as a 12th bit overall. This would only tell you there was an error in the number of odd/even bits in the 9 DCS data bits and prevent your squelch from opening on these types of bogus codes. However, it will never correct any of the bad bits and it will just stop you from using any DCS code with a parity error. If the bit errors knock out pairs of zero or one bits, then the parity check will still pass a bogus DCS code to operate your squelch, just like before. Keeping this phony "what if DCS worked like a serial modem" in mind, lets compare it to the real DCS based operation. The phony DCS example never does any error correction, it can be setup to block DCS codes that do not match the parity bit test, but the parity test can also fail, and your squelch never opens for the correct DCS code when bit errors are present. The real DCS can correct up to 3 bit errors and only returns bogus DCS codes when the bit error rate goes to 4 bit error rate or higher. At the 4 bit error rate or higher, it starts to act like the phony DCS example without parity and you have to get to a 6 bit error rate or higher before it completely starts acting like the phony DCS example. When the real DCS error correction works, your squelch will open for the programmed DCS code even when bit errors are present. Clearly, DCS with error correction is superior to the modem based phony DCS example. However, if you are only interested in opening your squelch for the correct code and can tolerate having your squelch not open at all when any bit errors are present, then you do not want to use simple DCS error correction. The real DCS 11 check bits are vastly superior to a parity bit for blocking unwanted DCS codes when bit errors are present in the received code.

Unique DCS codes:

Next, the four 112, 250, 505 and 512 DCS codes have no inverted signal DCS codes. You can invert the signal from one of these codes, but the only way to use this inverted signal is to re-invert it back to normal polarity, because the inverted signal can not produce any 100 signature match (there is no alternate DCS code). Here is what happens to the table in the example for the 023 DCS code, when changed for the 112 code group (remember, this is a DCS code group so 112 represents the 250, 505 and 512 codes which will be ignored):

 Tx same as Rx +112 112 112 +112
 Tx same as Rx +112 112 112 no alternate code
 Tx same as Rx no alternate code

 Tx same as Rx no alternate code

 Tx same as Rx -112 invalid bit stream invalid bit stream -112
 Tx same as Rx -112 invalid bit stream invalid bit stream no alternate code
 Tx same as Rx no alternate code

 Tx same as Rx no alternate code

 Tx opposite Rx +112 112 invalid bit stream -112
 Tx opposite Rx +112 112 invalid bit stream no alternate code
 Tx opposite Rx no alternate code

 Tx opposite Rx no alternate code

 Tx opposite Rx -112 invalid bit stream 112 +112
 Tx opposite Rx -112 invalid bit stream 112 no alternate code
 Tx opposite Rx no alternate code

 Tx opposite Rx no alternate code

You can see the only way possible to recover the 112 DCS code is make sure it has normal polarity at the receiver. An inverted 23-bit DCS word signal for 112 is shown as an "invalid bit stream" because it has no 100 signature match until it is inverted back to a normal polarity signal. Since there is no valid alternate DCS code for an inverted 112 DCS signal, all of the places where an inverted alternate code appeared in the first table are replaced with "no alternate code" in this table. When there is no inverted code to program for Tx, the rest of the information in that row is removed.

The encoding and decoding math still works on the invalid bit stream. It is called an invalid DCS bit stream because it violates the 100 signature match. When you invert the 23-bit DCS word for DCS code 112, you do not get any two consecutive zero values and it is impossible to come up with a 100 binary value without two consecutive zero values. Just keep in mind that the invalid bit stream changes back into a positive 23-bit DCS word for DCS code 112 when the signal is inverted again.

The table below is all that is left from the table above:

 Tx same as Rx +112 112 112  +112

 Tx same as Rx -112 invalid bit stream invalid bit stream -112

 Tx opposite Rx +112 112 invalid bit stream -112

 Tx opposite Rx -112 invalid bit stream 112  +112

Keep in mind that out of all the 512 decimal DCS codes, the 112, 250, 505 and 512 octal DCS codes (they all belong to the same DCS code group) are the only ones that act this way. Again, there is no way to know if your receiver has the same signal polarity as someone else's transmitter, unless both radios are the same brand and model. You will just have to try programming +112 or -112 until you find out which one works.

DCS decoding reliability:

Previously it was mentioned that phase modulation was not ideal for DCS signals. Specifically, some DCS codes like 000 produce this 23-bit stream:
11000111010-100-000/000/000 - 000

If you count the contiguous 0 bits in this 23 bit stream you will see eleven zero bits. The timing diagram shows how NRZ coding stretches each DCS bit to the entire time period of a 134.3 cycles per second timing signal. In other words, the NRZ signal can turn 134.3 Hz bit rate timing into a 67.15 Hz signal. When NRZ coding sends these eleven zero values at 134.3 Hz bit timing rate, it will produce a very low frequency component of this particular DCS signal. The eleven NRZ zeros will look like one half of a 6.1 Hz signal. Well, very low frequencies are exactly what phase modulation has trouble with, so this is an example of a DCS code that probably would not work with any phase modulated transmitter.

In addition, remember DCS is an asynchronous serial bit stream that only works when both the Tx and Rx use the same 134.3 Hz bit timing rate. If one of them is off (faster or slower), it can make it harder to Rx a DCS code. If the bit timing rate on Tx is faster and the Rx is slower (or vice versa) then it makes it even harder to Rx a DCS code (sometimes maybe even not possible). Now consider what happens when you have no DCS signal transitions for eleven bits (in the DCS code 000 example above). Any mismatch in the bit timing between the Tx and Rx will be multiplied by eleven. This is because each transition gives the receiver something to re-synchronize its timing to. A long blank stretch with no transitions does not allow the Rx to refresh its DCS signal timing synchronization. This makes DCS code 000 very difficult to use, even with true FM modulation transmitters. It can be done, but only if each radio has very precise DCS hardware/firmware. This is another reason why some DCS codes were not included in the standard set of 83 codes.

The above DCS code 000 examples are some of the problems that make it harder to use all of the 177 decimal DCS code groups. The idea behind DCS is to have a robust easy to use encoded squelch system that works with any DCS capable radio. All 177 decimal unique DCS codes probably could be used on DCS only channels (do not forget, you do not want to false any CTCSS decoders). Radios that tried to use all 177 decimal DCS codes would need to have well designed hardware and firmware (sloppy design or DCS detection programming would probably lead to failures). Also keep in mind that the DCS Tx filter and generator rounds off the sharp edges of the DCS signal square wave which makes it harder to synchronize with and detect DCS bits correctly. Still, you might be able to use any non-standard unique code if you test all the transmitter(s) and receiver(s) together first. Depending on their hardware design you might possibly also have to take thermal stress into account and test the equipment at different operating temperatures.

DCS reverse burst:

Another feature of DPL / DCS is the 134.3 Hz reverse burst tone. Technically this is a DPL / DCS code to a tone change transition or 134.3 Hz "turn off tone", and is not similar to how PL / CTCSS reverse burst works (which phase shifts the same frequency tone). However, it is commonly called a reverse burst because it accomplishes exactly the same audio muting task as the PL / CTCSS reverse burst. When a receiver using a DPL / DCS code to control its squelch opening sees the 134.3 Hz reverse burst, it turns off the receive squelch while the reverse burst tone is still being sent. This eliminates the squelch tail noise burst when the received signal drops out. This DPL / DCS reverse burst is exactly the same for Motorola and other manufacturers radios (they all work together without problems). When PL / CTCSS and DPL / DCS are both used on the same radio frequency (channel/mode/etc.), it is worth noting that 131.8 Hz and 136.5 Hz are both PL / CTCSS tones. The DPL / DCS reverse burst can false some receivers using these PL / CTCSS tones. It depends on the transmitter and receiver. The transmitter DPL / DCS reverse burst tone could be off frequency, the receiver PL / CTCSS decoder may not be on frequency or the receiver PL / CTCSS decoder may not be selective enough to reject the nearby DPL / DCS reverse burst tone. This potential problem is why some people do not like to use these two PL / CTCSS tones on frequencies that also have DPL / DCS on them.

BTW, there is information claiming the DCS bit rate is 134.3 Hz and there is information claiming the DCS bit timing rate is 134.4 Hz. I do not know which one is actually correct.








PL, Private Line, DPL, Digital Private Line, Vibrasponder, MPL, Talkaround, MDC-600, MDC-1200, MVS-20, Securenet, Smartnet, Privacy Plus, Trunked X2, Trunked X3, Touch Code, Quick Call II, Channel Scan, Talkback Scan, System 90, System 90*s, Systems 9000, PAC, PAC-PL, PAC-RT, PAC-TR, PAC-TL, MX-310, HT220, Mitrek, Micor, Spectra, MataTrac, Syntor, Syntor X, Syntor X 9000 and Syntor X 9000E are trademarks of Motorola Inc.