Categorygithub.com/pd0mz/go-dmr
modulepackage
0.0.0-20240303214853-344dc5b366d3
Repository: https://github.com/pd0mz/go-dmr.git
Documentation: pkg.go.dev
Overview
Versions
1
Dependencies
11
Dependents
7
Files
1.8k SLOC

# README

go-dmr

Golang Digital Mobile Radio protocols.

Build Status

References

The DMR Air Interface protocol is specified in Electromagnetic compatibility and Radio spectrum Matters (ERM); Digital Mobile Radio (DMR) Systems; Part 1: DMR Air Interface (AI) protocol, ETSI TS 102 361-1.

The Brandmeister Homebrew protocol is specified in IPSC Protocol Specs for homebrew DMR repeater by Hans DL5DI, Jonathan Naylor (G4KLXG) and Torsten Schultze (DG1HT).

Warning

This implementation is not suitable for commercial use and is for educational purposes only.

Acknowledgements

The implementation is possible because of the invaluable help from the following persons. Thanks for your patience and providing me with sample data and links to test the protocols.

  • Rudy Hardeman (PD0ZRY)
  • Artem Prilutskiy (R3ABM)

# Packages

No description provided by the author
No description provided by the author
Package homebrew implements the Home Brew DMR IPSC protocol.
Package ipsc implements the Motorola IP Site Connect protocol.
No description provided by the author
No description provided by the author
No description provided by the author
Package vbptc implements the Variable length BPTC for embedded signalling.

# Functions

BitsToBytes converts a byte slice of bits to a byte slice.
No description provided by the author
BytesToBits converts a byte slice to a byte slice representing the individual data bits.
No description provided by the author
DeinterleaveEmbeddedSignallingLC deinterleaves the embedded signalling LC bits.
No description provided by the author
No description provided by the author
No description provided by the author
ParseEMB parses embedded signalling.
ParseEMBBitsFromSync extracts the embedded signalling bits from the SYNC bits.
ParseEmbeddedSignallingLCFromSyncBits extracts the embedded signalling LC from the SYNC bits.
No description provided by the author
No description provided by the author

# Constants

Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Because Go doesn't have binary literals ("We've found hex and octal to be sufficient").
Call Type.
Call Type.
EMB LCSS fragments.
Carries a control block.
Carries addressing and numbering of packet data blocks.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
UDT Response Header DD Format.
Various sizes of information chunks.
Various sizes of information chunks.
Various sizes of information chunks.
EMB LCSS fragments.
Fills channel when no info to transmit.
Various sizes of information chunks.
Various sizes of information chunks.
After BPTC(196, 96) decoding.
Data Type information element definitions, DMR Air Interface (AI) protocol, Table 6.1.
EMB LCSS fragments.
n_DFragMax, see DMR AI spec.
Header for multi-block control.
Follow-on blocks for multi-block control.
Control Block Opcode.
Control Block Opcode.
0b0011.
0b1111.
0b0001.
0b1101.
0b1110.
0b0000.
0b0010.
Various sizes of information chunks.
Control Block Opcode.
Privacy Indicator information in a standalone burst.
Payload for rate 1/2 packet data.
Payload for rate 3⁄4 packet data.
Class 0b00, Type 0b001.
Class 0b01, Type 0b110.
Class 0b01, Type 0b000.
Class 0b01, Type 0b010.
Class 0b01, Type 0b001.
Class 0b01, Type 0b011.
Class 0b01, Type 0b101.
Class 0b10, Type 0b000.
Class 0b01, Type 0b100.
0b0101.
0b0100.
0b1001.
0b1010.
0b0010.
0b0011.
0b0000.
Various sizes of information chunks.
EMB LCSS fragments.
Various sizes of information chunks.
Various sizes of information chunks.
Various sizes of information chunks.
Various sizes of information chunks.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Table 9.2: SYNC Patterns.
Indicates the end of transmission, carries LC information.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
UDP Response Header UDT Format.
Control Block Opcode.
Control Block Opcode.
Data Type information element definitions, DMR Air Interface (AI) protocol, Table 6.1.
Various sizes of information chunks.
Burst A marks the start of a superframe and always contains a voice SYNC pattern.
Bursts B to F carry embedded signalling in place of the SYNC pattern.
Bursts B to F carry embedded signalling in place of the SYNC pattern.
Bursts B to F carry embedded signalling in place of the SYNC pattern.
Bursts B to F carry embedded signalling in place of the SYNC pattern.
Bursts B to F carry embedded signalling in place of the SYNC pattern.
Various sizes of information chunks.
Indicates the beginning of voice transmission, carries addressing information.

# Variables

No description provided by the author
No description provided by the author
No description provided by the author
LCSSName is a map of LCSS fragment type to string.
http://www.etsi.org/images/files/DMRcodes/dmrs-mfid.xls.
Package identifier.
No description provided by the author
No description provided by the author
Software identifier.
No description provided by the author
No description provided by the author
Version number.

# Structs

No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
EMB contains embedded signalling.
EmbeddedSignallingLC contains the embedded signalling LC and checksum.
No description provided by the author
No description provided by the author
Packet represents a frame transported by the Air Interface.
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author
No description provided by the author

# Interfaces

No description provided by the author
No description provided by the author
Repeater implements a repeater station.

# Type aliases

PacketFunc is a callback function that handles DMR packets.