From 28a2703d16eedde313ae084400a44e1d6f6c40fe Mon Sep 17 00:00:00 2001 From: cheetah Date: Tue, 22 Oct 2019 22:12:35 +0200 Subject: [PATCH] Create pocsag.py --- pocsag.py | 407 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 407 insertions(+) create mode 100644 pocsag.py diff --git a/pocsag.py b/pocsag.py new file mode 100644 index 0000000..f8d7eae --- /dev/null +++ b/pocsag.py @@ -0,0 +1,407 @@ +import ctypes +import struct +""" + +** 11.09.2019 : Added Numeric Pager support by cuddlycheetah (github.com/cuddlycheetah) +** 14.10.2019 : Added Repeating Transmission + Single Preamble Mode (github.com/cuddlycheetah) +** 22.10.2019 : Made the Original (from rpitx) to a Python Encoder. (github.com/cuddlycheetah) +""" +#The sync word exists at the start of every batch. +#A batch is 16 words, a sync word occurs every 16 data words. +SYNC=0x7CD215D8 + +#The idle word is used as padding before the address word, at the end +#of a message to indicate that the message is finished. Interestingly, the +#idle word does not have a valid CRC code, the sync word does. +IDLE=0x7A89C197 + +#One frame consists of a pair of two words +FRAME_SIZE = 2 + +#One batch consists of 8 frames, 16 words +BATCH_SIZE = 16 + +#The preamble comes before a message, is a series of alternating +#1,0,1,0... bits, at least 576 bits. It exists to allow the receiver +#to synchronize with the transmitter +PREAMBLE_LENGTH = 576 + +#These bits appear as the first bit of a word, for an address word and +#one for a data word +FLAG_ADDRESS = 0x000000 +FLAG_MESSAGE = 0x100000 + +#The last two bits of an address word's data represent the data type +#0x3 for text, 0x0 for numeric. +FLAG_TEXT_DATA = 0x3 +FLAG_NUMERIC_DATA = 0x0 + +#Each data word can contain 20 bits of text information. Each character is +#7 bits wide, encoded. The bit order of the characters is reversed from +#the normal bit order; the most significant bit of a word corresponds to the +#least significant bit of a character it is encoding. The characters are split +#across the words of a message to ensure maximal usage of all bits. +TEXT_BITS_PER_WORD = 20 + +#As mentioned above, are 7 bit ASCII encoded +TEXT_BITS_PER_CHAR = 7 + +NUMERIC_BITS_PER_WORD = 20 +NUMERIC_BITS_PER_DIGIT = 4 + +#Length of CRC codes in bits +CRC_BITS=10 + +#The CRC generator polynomial +CRC_GENERATOR=0b11101101001 + + + + + +'''* + * Calculate the CRC error checking code for the given word. + * Messages use a 10 bit CRC computed from the 21 data bits. + * This is calculated through a binary polynomial long division, returning + * the remainder. + * See https:#en.wikipedia.org/wiki/Cyclic_redundancy_check#Computation + * for more information. +''' +def crc(inputMsg): + #Align MSB of denominatorerator with MSB of message + denominator = CRC_GENERATOR << 20 + + #Message is right-padded with zeroes to the message length + crc length + msg = inputMsg << CRC_BITS + + #We iterate until denominator has been right-shifted back to it's original value. + for column in range(20 + 1): + #Bit for the column we're aligned to + msgBit = (msg >> (30 - column)) & 1 + + #If the current bit is zero, don't modify the message self iteration + if msgBit != 0: + #While we would normally subtract in long division, XOR here. + msg ^= denominator + + + #Shift the denominator over to align with the next column + denominator >>= 1 + + + #At self point 'msg' contains the CRC value we've calculated + return msg & 0x3FF + +'''* + * Calculates the even parity bit for a message. + * If the number of bits in the message is even, 0, return 1. +''' +def parity(x): + #Our parity bit + p = 0 + + #We xor p with each bit of the input value. This works because + #xoring two one-bits will cancel out and leave a zero bit. Thus + #xoring any even number of one bits will result in zero, xoring + #any odd number of one bits will result in one. + for i in range(32): + p ^= (x & 1) + x >>= 1 + + return p + +'''* + * Encodes a 21-bit message by calculating and adding a CRC code and parity bit. +''' +def encodeCodeword(msg): + fullCRC = (msg << CRC_BITS) | crc(msg) + p = parity(fullCRC) + return (fullCRC << 1) | p + +'''* + * ASCII encode a null-terminated string as a series of codewords, written + * to (*out). Returns the number of codewords written. Caller should ensure + * that enough memory is allocated in (*out) to contain the message + * + * initial_offset indicates which word in the current batch the function is + * beginning at, that it can insert SYNC words at appropriate locations. +''' +def encodeASCII(initial_offset, text, buff): + #Number of words written to *out + numWordsWritten = 0 + + #Data for the current word we're writing + currentWord = 0 + #Nnumber of bits we've written so far to the current word + currentNumBits = 0 + + #Position of current word in the current batch + wordPosition = initial_offset + + for c in text: + #Encode the character bits backwards + for i in range(TEXT_BITS_PER_CHAR): + currentWord <<= 1 + currentWord |= (ord(c) >> i) & 1 + currentNumBits+=1 + if currentNumBits == TEXT_BITS_PER_WORD: + #Add the MESSAGE flag to our current word and encode it. + buff.append(encodeCodeword(currentWord | FLAG_MESSAGE)) + currentWord = 0 + currentNumBits = 0 + numWordsWritten+=1 + + wordPosition+=1 + if wordPosition == BATCH_SIZE: + #We've filled a full batch, to insert a SYNC word + #and start a one. + buff.append(SYNC) + numWordsWritten+=1 + wordPosition = 0 + #Write remainder of message + if currentNumBits > 0: + #Pad out the word to 20 bits with zeroes + currentWord <<= 20 - currentNumBits + buff.append(encodeCodeword(currentWord | FLAG_MESSAGE)) + numWordsWritten+=1 + + wordPosition+=1 + if wordPosition == BATCH_SIZE: + #We've filled a full batch, to insert a SYNC word + #and start a one. + buff.append(SYNC) + numWordsWritten+=1 + wordPosition = 0 + return numWordsWritten + +# Char Translationtable +mirrorTab = [0x00, 0x08, 0x04, 0x0c, 0x02, 0x0a, 0x06, 0x0e, 0x01, 0x09] +def encodeDigit(ch): + if ch >= '0' and ch <= '9': + return mirrorTab[ch - '0'] + elif ch == ' ': + return 0x03 + elif ch == 'u' or ch == 'U': + return 0x0d + elif ch == '-' or ch == '_': + return 0x0b + elif ch == '(' or ch == '[': + return 0x0f + elif ch == ')' or ch == ']': + return 0x07 + else: + return 0x05 + +def encodeNumeric(initial_offset, text, buff): + #Number of words written to *out + numWordsWritten = 0 + + #Data for the current word we're writing + currentWord = 0 + + #Nnumber of bits we've written so far to the current word + currentNumBits = 0 + + #Position of current word in the current batch + wordPosition = initial_offset + + for c in text: + #Encode the digit bits backwards + for i in range(NUMERIC_BITS_PER_DIGIT): + currentWord <<= 1 + digit = encodeDigit(c) + digit = ((digit & 1) << 3) | ((digit & 2) << 1) | ((digit & 4) >> 1) | ((digit & 8) >> 3) + + currentWord |= (digit >> i) & 1 + currentNumBits+=1 + if currentNumBits == NUMERIC_BITS_PER_WORD: + #Add the MESSAGE flag to our current word and encode it. + buff.append(encodeCodeword(currentWord | FLAG_MESSAGE)) + currentWord = 0 + currentNumBits = 0 + numWordsWritten+=1 + + wordPosition+=1 + if wordPosition == BATCH_SIZE: + #We've filled a full batch, to insert a SYNC word + #and start a one. + buff.append(SYNC) + numWordsWritten+=1 + wordPosition = 0 + #Write remainder of message + if currentNumBits > 0: + #Pad out the word to 20 bits with zeroes + currentWord <<= 20 - currentNumBits + buff.append(encodeCodeword(currentWord | FLAG_MESSAGE)) + numWordsWritten+=1 + + wordPosition+=1 + if wordPosition == BATCH_SIZE: + #We've filled a full batch, to insert a SYNC word + #and start a one. + buff.append(SYNC) + numWordsWritten+=1 + wordPosition = 0 + return numWordsWritten + +'''* + * An address of 21 bits, only 18 of those bits are encoded in the address + * word itself. The remaining 3 bits are derived from which frame in the batch + * is the address word. This calculates the number of words (not framesnot ) + * which must precede the address word so that it is in the right spot. These + * words will be filled with the idle value. +''' +def addressOffset(address): + return (address & 0x7) * FRAME_SIZE + +'''* + * Calculates the length in words of a text POCSAG message, the address + * and the number of characters to be transmitted. + ''' +def textMessageLength(repeatIndex, address, numChars): + numWords = 0 + + #Padding before address word. + numWords += addressOffset(address) + + #Address word itself + numWords+=1 + + #numChars * 7 bits per character / 20 bits per word, up + numWords += (numChars * TEXT_BITS_PER_CHAR + (TEXT_BITS_PER_WORD - 1)) / TEXT_BITS_PER_WORD + + #Idle word representing end of message + numWords+=1 + + #Pad out last batch with idles + numWords += BATCH_SIZE - (numWords % BATCH_SIZE) + + #Batches consist of 16 words each and are preceded by a sync word. + #So we add one word for every 16 message words + numWords += numWords / BATCH_SIZE + + #Preamble of 576 alternating 1,0,1, bits before the message + #Even though self comes first, add it to the length last so it + #doesn't affect the other word-based calculations + if repeatIndex == 0: + numWords += PREAMBLE_LENGTH / 32 + + return numWords + + +'''* + * Calculates the length in words of a numeric POCSAG message, the address + * and the number of characters to be transmitted. +''' +def numericMessageLength(repeatIndex, address, numChars): + numWords = 0 + + #Padding before address word. + numWords += addressOffset(address) + + #Address word itself + numWords+=1 + + #numChars * 7 bits per character / 20 bits per word, up + numWords += (numChars * NUMERIC_BITS_PER_DIGIT + (NUMERIC_BITS_PER_WORD - 1)) / NUMERIC_BITS_PER_WORD + + #Idle word representing end of message + numWords+=1 + + #Pad out last batch with idles + numWords += BATCH_SIZE - (numWords % BATCH_SIZE) + + #Batches consist of 16 words each and are preceded by a sync word. + #So we add one word for every 16 message words + numWords += numWords / BATCH_SIZE + + #Preamble of 576 alternating 1,0,1, bits before the message + #Even though self comes first, add it to the length last so it + #doesn't affect the other word-based calculations + if repeatIndex == 0: + numWords += PREAMBLE_LENGTH / 32 + + return numWords + + +def encodeTransmission(numeric, repeatIndex, address, fb, message, buff): + out=0 + #Encode preamble + #Alternating 1,0,1, bits for 576 bits, for receiver to synchronize + #with transmitter + if repeatIndex == 0: + for i in range(PREAMBLE_LENGTH / 32): + buff.append(0xAAAAAAAA) + out+=1 + start = out + + #Sync + buff.append(SYNC) + out+=1 + + #Write out padding before adderss word + prefixLength = addressOffset(address) + for i in range(prefixLength): + buff.append(IDLE) + out+=1 + + #Write address word. + #The last two bits of word's data contain the message type (function bits) + #The 3 least significant bits are dropped, those are encoded by the + #word's location. + buff.append(encodeCodeword(((address >> 3) << 2) | fb)) + out+=1 + + #Encode the message itself + if numeric == True: + out += encodeNumeric(addressOffset(address) + 1, message, buff) + else: + out += encodeASCII(addressOffset(address) + 1, message, buff) + + + #Finally, an IDLE word indicating the end of the message + buff.append(IDLE) + out+=1 + + #Pad out the last batch with IDLE to write multiple of BATCH_SIZE + 1 + #words (+ 1 is there because of the SYNC words) + written = out - start + padding = (BATCH_SIZE + 1) - written % (BATCH_SIZE + 1) + for i in range(padding): + buff.append(IDLE) + out+=1 + +def parseAddress(address): + if address.find('A') > 0: + return [address[:address.index('A')], 0] + elif address.find('B') > 0: + return [address[:address.index('B')], 1] + elif address.find('C') > 0: + return [address[:address.index('C')], 2] + elif address.find('D') > 0: + return [address[:address.index('D')], 3] + else: + return [address, 3] + +def encodeTXBatch(messages, repeatNum = 2, inverted = False): + transmission = [] + pocsagData = [] + msgIndex = 0 + for message in messages: + msgNumeric = message[0] + msgAddrParsed = parseAddress(message[1]) + msgAddress = int(msgAddrParsed[0]) + msgBits = msgAddrParsed[1] + msgText = message[2] + for repeat in range(repeatNum): + encodeTransmission(msgNumeric, msgIndex, msgAddress, msgBits, msgText, transmission) + msgIndex += 1 + for word in transmission: + uint = ctypes.c_uint32(word).value + if not inverted: + uint = ~uint + pocsagData.append(int((uint>>24) & 0xFF)) + pocsagData.append(int((uint>>16) & 0xFF)) + pocsagData.append(int((uint>>8) & 0xFF)) + pocsagData.append(int(uint & 0xFF)) + return pocsagData