Files
brnQuanFW/tests/test_pocsag.c
T
2026-11-15 00:58:12 +01:00

135 lines
5.8 KiB
C

// Host-side test: cc -std=c11 -I. tests/test_pocsag.c app/pocsag.c -o test_pocsag && ./test_pocsag
#include "app/pocsag.h"
#include <assert.h>
#include <stdio.h>
#include <stdint.h>
#include <string.h>
// Known-good page (from the uv-k5-pocsag reference): RIC 260321, "test 1234 miau! :3",
// followed by a second page in the next batch. Logical bit order, MSB first.
static const uint8_t reference_batch[] = {
0x7C, 0xD2, 0x15, 0xD8, 0x7A, 0x89, 0xC1, 0x97, 0x7A, 0x89, 0xC1, 0x97, 0x0F, 0xE3, 0x9E, 0x99,
0x97, 0xA7, 0x9B, 0x51, 0xCB, 0x82, 0x8F, 0x72, 0xC9, 0xB3, 0x13, 0x0C, 0xE0, 0x56, 0xE2, 0x79,
0xDC, 0x3A, 0xF1, 0xB4, 0x88, 0x12, 0xEB, 0xE1, 0xCC, 0x00, 0x01, 0x97, 0x7A, 0x89, 0xC1, 0x97,
0x7A, 0x89, 0xC1, 0x97, 0x7A, 0x89, 0xC1, 0x97, 0x7A, 0x89, 0xC1, 0x97, 0x7A, 0x89, 0xC1, 0x97,
0x7A, 0x89, 0xC1, 0x97,
};
static void invert(uint8_t *buffer, size_t size)
{
for (size_t i = 0; i < size; i++)
buffer[i] = (uint8_t)~buffer[i];
}
int main(void)
{
static const uint32_t capcodes[] = {0, 1, 7, 8, 123456, 260321, 0x1FFFFF};
uint8_t frame[POCSAG_MAX_FRAME_SIZE];
char decoded[POCSAG_MAX_MESSAGE_LENGTH + 1U];
uint32_t sender;
size_t frame_size;
// Encoder must match the reference transmitter bit for bit.
assert(POCSAG_Encode(260321U, "test 1234 miau! :3", frame, sizeof(frame), &frame_size));
assert(frame_size == POCSAG_MAX_FRAME_SIZE);
for (size_t i = 0; i < POCSAG_PREAMBLE_BYTES; i++)
assert(frame[i] == 0xAA);
if (memcmp(frame + POCSAG_PREAMBLE_BYTES, reference_batch, sizeof(reference_batch)) != 0) {
fprintf(stderr, "encoder output differs from reference batch\n");
return 1;
}
// Decoder must read the reference.
assert(POCSAG_Decode(reference_batch, sizeof(reference_batch), 260321U, &sender,
decoded, sizeof(decoded)));
assert(sender == 260321U);
assert(strcmp(decoded, "test 1234 miau! :3") == 0);
assert(!POCSAG_Decode(reference_batch, sizeof(reference_batch), 260320U, NULL,
decoded, sizeof(decoded)));
for (size_t i = 0; i < sizeof(capcodes) / sizeof(capcodes[0]); i++) {
static const char *messages[] = {"Hello pager", "12345678901234567890", "A"};
for (size_t m = 0; m < sizeof(messages) / sizeof(messages[0]); m++) {
assert(POCSAG_Encode(capcodes[i], messages[m], frame, sizeof(frame), &frame_size));
assert(frame_size == POCSAG_MAX_FRAME_SIZE);
sender = 0xFFFFFFFFU;
if (!POCSAG_Decode(frame, frame_size, capcodes[i], &sender, decoded, sizeof(decoded)) ||
strcmp(decoded, messages[m]) != 0) {
fprintf(stderr, "decode failed for capcode %lu '%s'\n",
(unsigned long)capcodes[i], messages[m]);
return 1;
}
assert(sender == capcodes[i]);
// What the radio's RX buffer looks like: sync + 128 bytes after the chip sync.
const uint8_t *rx = frame + POCSAG_PREAMBLE_BYTES;
assert(POCSAG_Decode(rx, 4U + 128U, capcodes[i], NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, messages[m]) == 0);
// Single bit error in the address codeword gets corrected.
const size_t address_byte = POCSAG_PREAMBLE_BYTES + 4U + (capcodes[i] & 7U) * 8U + 1U;
frame[address_byte] ^= 0x10U;
assert(POCSAG_Decode(frame, frame_size, capcodes[i], NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, messages[m]) == 0);
frame[address_byte] ^= 0x10U;
// Inverted polarity is detected via the inverted sync word.
invert(frame, frame_size);
assert(POCSAG_Decode(frame, frame_size, capcodes[i], NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, messages[m]) == 0);
invert(frame, frame_size);
assert(!POCSAG_Decode(frame, frame_size, capcodes[i] ^ 0x100U, NULL,
decoded, sizeof(decoded)));
}
}
// Radio RX: the chip locks anywhere in the preamble and the capture is cut off
// when the transmission ends (decoded on squelch close), in both FIFO byte orders.
assert(POCSAG_Encode(1234567U, "12345678901234567890", frame, sizeof(frame), NULL));
for (size_t lock = 0; lock < POCSAG_PREAMBLE_BYTES; lock++) {
const size_t size = sizeof(frame) - lock;
assert(POCSAG_Decode(frame + lock, size, 1234567U, NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, "12345678901234567890") == 0);
}
// Sync codeword with 2 bit errors (both batches) still decodes, also inverted.
assert(POCSAG_Encode(1234567U, "sync errors", frame, sizeof(frame), NULL));
frame[POCSAG_PREAMBLE_BYTES] ^= 0x81U;
frame[POCSAG_PREAMBLE_BYTES + POCSAG_BATCH_BYTES + 2U] ^= 0x18U;
assert(POCSAG_Decode(frame, sizeof(frame), 1234567U, NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, "sync errors") == 0);
invert(frame, sizeof(frame));
assert(POCSAG_Decode(frame, sizeof(frame), 1234567U, NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, "sync errors") == 0);
// Monitor mode: any address decodes and reports the RIC.
assert(POCSAG_Encode(1234567U, "Ahoj", frame, sizeof(frame), NULL));
assert(POCSAG_Decode(frame, sizeof(frame), POCSAG_ANY_RIC, &sender, decoded, sizeof(decoded)));
assert(sender == 1234567U && strcmp(decoded, "Ahoj") == 0);
assert(!POCSAG_Encode(0x200000U, "bad", frame, sizeof(frame), NULL));
assert(!POCSAG_Encode(123U, "", frame, sizeof(frame), NULL));
// longest message, for every frame position, then one character too many
{
char longest[POCSAG_MAX_MESSAGE_LENGTH + 2U];
for (size_t i = 0; i < POCSAG_MAX_MESSAGE_LENGTH + 1U; i++)
longest[i] = (char) ('A' + i % 26U);
longest[POCSAG_MAX_MESSAGE_LENGTH] = '\0';
for (uint32_t ric = 0; ric < 8U; ric++) {
assert(POCSAG_Encode(1000000U + ric, longest, frame, sizeof(frame), NULL));
assert(POCSAG_Decode(frame, sizeof(frame), 1000000U + ric, NULL, decoded, sizeof(decoded)));
assert(strcmp(decoded, longest) == 0);
}
longest[POCSAG_MAX_MESSAGE_LENGTH] = 'X';
longest[POCSAG_MAX_MESSAGE_LENGTH + 1U] = '\0';
assert(!POCSAG_Encode(123U, longest, frame, sizeof(frame), NULL));
}
assert(!POCSAG_Encode(123U, "ok", frame, sizeof(frame) - 1U, NULL));
puts("pocsag tests passed");
return 0;
}