// // Created by bruno on 3/30/25. // // OOK remote code sender. The carrier is generated in TX mode with the audio // muted and keyed with the PA enable line (fast SPI write, ~25 us). Every edge // is scheduled on an absolute SysTick clock, so the write latency is the same // for every edge and does not change pulse widths, and nothing drifts. // #include "ooksender.h" #include #include "ARMCM0.h" #include "audio.h" #include "driver/bk4819.h" #include "driver/system.h" #include "frequencies.h" #include "misc.h" #include "radio.h" #include "ui/ooksender.h" #include "ui/ui.h" uint8_t gOOKSenderState = OOKSENDER_PROTO_CHOOSE; uint8_t gOOKSenderProtocol = OOKSENDER_PROTO_EV1527; uint8_t gOOKSenderField = OOK_FIELD_CODE; uint32_t gOOKSenderValue[OOK_FIELD_COUNT]; #define PT2262_MAX_TRITS 12U // rc-switch protocols: pulse length, then (high, low) in pulses for sync, 0 and 1. // Data bits are sent MSB first, followed by the sync (rc-switch order). typedef struct { uint16_t pulse_us; uint8_t sync[2]; uint8_t zero[2]; uint8_t one[2]; bool inverted; } OOK_RcProtocol_t; static const OOK_RcProtocol_t rcProtocols[7] = { {350, {1, 31}, {1, 3}, {3, 1}, false}, // 1: PT2262, EV1527, most cheap remotes {650, {1, 10}, {1, 2}, {2, 1}, false}, // 2 {100, {30, 71}, {4, 11}, {9, 6}, false}, // 3 {380, {1, 6}, {1, 3}, {3, 1}, false}, // 4 {500, {6, 14}, {1, 2}, {2, 1}, false}, // 5 {450, {23, 1}, {1, 2}, {2, 1}, true}, // 6: HT6P20B {150, {2, 62}, {1, 6}, {6, 1}, false}, // 7: HS2303-PT }; // Field labels per protocol, index into labelText (0 = field not used) static const char labelText[][7] = {"", "Code", "ID", "Key", "Bits", "Proto", "Unit", "On", "Pulse", "Half", "Repeat"}; static const uint8_t fieldLabels[OOKSENDER_PROTO_END][OOK_FIELD_COUNT] = { [OOKSENDER_PROTO_PT2262] = {1, 0, 0, 8, 10}, [OOKSENDER_PROTO_EV1527] = {2, 3, 0, 8, 10}, [OOKSENDER_PROTO_RCSWITCH] = {1, 4, 5, 8, 10}, [OOKSENDER_PROTO_INTERTECHNO] = {2, 6, 7, 8, 10}, [OOKSENDER_PROTO_MANCHESTER] = {1, 4, 0, 9, 10}, }; // Largest value per field: code / ID in bits, the others plain static const uint8_t codeBits[OOKSENDER_PROTO_END] = {24, 20, 32, 26, 32}; static const uint8_t argMax[OOKSENDER_PROTO_END] = {PT2262_MAX_TRITS, 15, 32, 15, 32}; static const uint8_t extraMax[OOKSENDER_PROTO_END] = {0, 0, 7, 1, 0}; static uint32_t OOK_FieldMax(const uint8_t field) { switch (field) { case OOK_FIELD_CODE: return codeBits[gOOKSenderProtocol] >= 32U ? 0xFFFFFFFFU : (1UL << codeBits[gOOKSenderProtocol]) - 1U; case OOK_FIELD_ARG: return argMax[gOOKSenderProtocol]; case OOK_FIELD_EXTRA: return extraMax[gOOKSenderProtocol]; case OOK_FIELD_PULSE: return 5000U; default: return 100U; } } const char *OOKSENDER_FieldLabel(const uint8_t protocol, const uint8_t field) { const uint8_t label = fieldLabels[protocol][field]; return label ? labelText[label] : NULL; } static void OOK_SetDefaults(void) { static const uint16_t pulse[OOKSENDER_PROTO_END] = {350, 350, 350, 260, 500}; static const uint8_t arg[OOKSENDER_PROTO_END] = {0, 0, 24, 0, 16}; gOOKSenderValue[OOK_FIELD_CODE] = 0; gOOKSenderValue[OOK_FIELD_ARG] = arg[gOOKSenderProtocol]; gOOKSenderValue[OOK_FIELD_EXTRA] = 1; // rc-switch protocol 1 / Intertechno "on" gOOKSenderValue[OOK_FIELD_PULSE] = pulse[gOOKSenderProtocol]; gOOKSenderValue[OOK_FIELD_REPEAT] = 10; gOOKSenderField = OOK_FIELD_CODE; } // ---------------------------------------------------------------- timing #define OOK_TICKS_PER_US 48U // SysTick runs on the 48 MHz core clock static uint32_t ookLastVal; static uint32_t ookNow; static uint32_t ookDue; // Monotonic 48 MHz tick count. SysTick counts down and reloads every 10 ms, so this // must be called more often than that (the busy waits below do). static uint32_t OOK_Ticks(void) { const uint32_t value = SysTick->VAL; ookNow += (ookLastVal >= value) ? ookLastVal - value : ookLastVal + SysTick->LOAD + 1U - value; ookLastVal = value; return ookNow; } // Switch the carrier at the scheduled time, then schedule the next edge. static void OOK_Level(const bool on, const uint32_t us) { while ((int32_t) (OOK_Ticks() - ookDue) < 0) { } BK4819_ToggleGpioOutFast(BK4819_GPIO1_PIN29_PA_ENABLE, on); ookDue += us * OOK_TICKS_PER_US; } static void OOK_Pair(const uint8_t ratio[2], const uint32_t pulse, const bool inverted) { OOK_Level(!inverted, ratio[0] * pulse); OOK_Level(inverted, ratio[1] * pulse); } // ---------------------------------------------------------------- encoders static void OOK_SendRcBits(const OOK_RcProtocol_t *p, const uint32_t code, const uint8_t bits, const uint32_t pulse) { for (uint8_t i = bits; i-- > 0;) OOK_Pair(((code >> i) & 1U) ? p->one : p->zero, pulse, p->inverted); OOK_Pair(p->sync, pulse, p->inverted); } static void OOK_SendFrame(void) { static const uint8_t itShort[2] = {1, 1}, itLong[2] = {1, 5}; static const uint8_t itStart[2] = {1, 10}, itEnd[2] = {1, 40}; const uint32_t code = gOOKSenderValue[OOK_FIELD_CODE]; const uint32_t arg = gOOKSenderValue[OOK_FIELD_ARG]; const uint32_t pulse = gOOKSenderValue[OOK_FIELD_PULSE]; const OOK_RcProtocol_t *p1 = &rcProtocols[0]; switch (gOOKSenderProtocol) { case OOKSENDER_PROTO_PT2262: // trit 0 = "0 0", trit 1 = "1 1", trit F = "0 1" (2 bits per trit in code) for (uint32_t i = arg; i-- > 0;) { const uint32_t trit = (code >> (2U * i)) & 3U; OOK_Pair(trit == 1U ? p1->one : p1->zero, pulse, false); OOK_Pair(trit == 0U ? p1->zero : p1->one, pulse, false); } OOK_Pair(p1->sync, pulse, false); break; case OOKSENDER_PROTO_EV1527: OOK_SendRcBits(p1, (code << 4) | (arg & 0x0FU), 24, pulse); break; case OOKSENDER_PROTO_RCSWITCH: OOK_SendRcBits(&rcProtocols[gOOKSenderValue[OOK_FIELD_EXTRA] - 1U], code, (uint8_t) arg, pulse); break; case OOKSENDER_PROTO_INTERTECHNO: { // 26 bit ID, group bit (0), on/off, 4 bit unit; bit 0 = short+long, 1 = long+short const uint32_t word = (code << 6) | ((gOOKSenderValue[OOK_FIELD_EXTRA] & 1U) << 4) | (arg & 0x0FU); OOK_Pair(itStart, pulse, false); for (uint8_t i = 32; i-- > 0;) { const bool one = (word >> i) & 1U; OOK_Pair(one ? itLong : itShort, pulse, false); OOK_Pair(one ? itShort : itLong, pulse, false); } OOK_Pair(itEnd, pulse, false); break; } case OOKSENDER_PROTO_MANCHESTER: // 1 = on/off, 0 = off/on (half bit each), then a 20 half-bit gap for (uint32_t i = arg; i-- > 0;) { const bool one = (code >> i) & 1U; OOK_Level(one, pulse); OOK_Level(!one, pulse); } OOK_Level(false, 20U * pulse); break; default: break; } } static bool OOK_Valid(void) { const uint32_t *v = gOOKSenderValue; if (v[OOK_FIELD_REPEAT] == 0 || v[OOK_FIELD_PULSE] < 50U) return false; switch (gOOKSenderProtocol) { case OOKSENDER_PROTO_PT2262: return v[OOK_FIELD_ARG] > 0; case OOKSENDER_PROTO_RCSWITCH: return v[OOK_FIELD_ARG] > 0 && v[OOK_FIELD_EXTRA] >= 1U && v[OOK_FIELD_EXTRA] <= 7U; case OOKSENDER_PROTO_MANCHESTER: return v[OOK_FIELD_ARG] > 0; default: return true; } } static void OOK_Transmit(void) { if (!OOK_Valid() || TX_freq_check(gCurrentVfo->pTX->Frequency) != 0) { AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); return; } gOOKSenderState = OOKSENDER_SENDING; OOKSENDER_Display(); // unmodulated carrier, PA switched off until the first pulse BK4819_EnterTxMute(); RADIO_SetTxParameters(); BK4819_WriteRegister(BK4819_REG_30, BK4819_REG_30_ENABLE_VCO_CALIB | BK4819_REG_30_ENABLE_UNKNOWN | BK4819_REG_30_DISABLE_RX_LINK | BK4819_REG_30_DISABLE_AF_DAC | BK4819_REG_30_ENABLE_DISC_MODE | BK4819_REG_30_ENABLE_PLL_VCO | BK4819_REG_30_ENABLE_PA_GAIN | BK4819_REG_30_DISABLE_MIC_ADC | BK4819_REG_30_ENABLE_TX_DSP | BK4819_REG_30_DISABLE_RX_DSP); BK4819_ToggleGpioOut(BK4819_GPIO1_PIN29_PA_ENABLE, false); BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, true); SYSTEM_DelayMs(20); ookLastVal = SysTick->VAL; ookNow = 0; ookDue = 200U * OOK_TICKS_PER_US; for (uint32_t r = 0; r < gOOKSenderValue[OOK_FIELD_REPEAT]; r++) OOK_SendFrame(); OOK_Level(false, 0); // end of the last pulse / gap SYSTEM_DelayMs(20); BK4819_SetupPowerAmplifier(0, 0); BK4819_ToggleGpioOut(BK4819_GPIO5_PIN1_RED, false); RADIO_SetupRegisters(true); // back to normal RX gOOKSenderState = OOKSENDER_DATA_INPUT; gUpdateDisplay = true; } // ---------------------------------------------------------------- keys static void OOK_NextField(const int8_t direction) { for (uint8_t n = 0; n < OOK_FIELD_COUNT; n++) { gOOKSenderField = (uint8_t) ((gOOKSenderField + OOK_FIELD_COUNT + direction) % OOK_FIELD_COUNT); if (fieldLabels[gOOKSenderProtocol][gOOKSenderField] != 0) return; } } static void OOK_Digit(const uint8_t digit) { uint32_t *value = &gOOKSenderValue[gOOKSenderField]; if (gOOKSenderProtocol == OOKSENDER_PROTO_PT2262 && gOOKSenderField == OOK_FIELD_CODE) { // keys 0, 1 and 2 (= F) append a trit if (digit > 2U || gOOKSenderValue[OOK_FIELD_ARG] >= PT2262_MAX_TRITS) { AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); return; } *value = (*value << 2) | digit; gOOKSenderValue[OOK_FIELD_ARG]++; return; } const uint32_t max = OOK_FieldMax(gOOKSenderField); if (*value > (max - digit) / 10U) { // value * 10 + digit > max, without overflow AUDIO_PlayBeep(BEEP_500HZ_60MS_DOUBLE_BEEP_OPTIONAL); return; } *value = *value * 10U + digit; // a new rc-switch protocol brings its own pulse length if (gOOKSenderProtocol == OOKSENDER_PROTO_RCSWITCH && gOOKSenderField == OOK_FIELD_EXTRA && *value >= 1U && *value <= 7U) gOOKSenderValue[OOK_FIELD_PULSE] = rcProtocols[*value - 1U].pulse_us; } // returns false when the field was already empty static bool OOK_Backspace(void) { uint32_t *value = &gOOKSenderValue[gOOKSenderField]; if (gOOKSenderProtocol == OOKSENDER_PROTO_PT2262 && gOOKSenderField == OOK_FIELD_CODE) { if (gOOKSenderValue[OOK_FIELD_ARG] == 0) return false; *value >>= 2; gOOKSenderValue[OOK_FIELD_ARG]--; return true; } if (*value == 0) return false; *value /= 10U; return true; } void OOKSENDER_TimeSlice500ms(void) { } void OOKSENDER_ProcessKeys(KEY_Code_t Key, bool bKeyPressed, bool bKeyHeld) { if (!bKeyPressed || bKeyHeld) return; switch (gOOKSenderState) { case OOKSENDER_PROTO_CHOOSE: if (Key == KEY_EXIT) { gRequestDisplayScreen = DISPLAY_MAIN; } else if (Key == KEY_MENU) { OOK_SetDefaults(); gOOKSenderState = OOKSENDER_DATA_INPUT; } else if (Key == KEY_UP) { gOOKSenderProtocol = (gOOKSenderProtocol + 1U) % OOKSENDER_PROTO_END; } else if (Key == KEY_DOWN) { gOOKSenderProtocol = (gOOKSenderProtocol + OOKSENDER_PROTO_END - 1U) % OOKSENDER_PROTO_END; } break; case OOKSENDER_DATA_INPUT: if (Key <= KEY_9) { OOK_Digit((uint8_t) (Key - KEY_0)); } else if (Key == KEY_UP) { OOK_NextField(-1); } else if (Key == KEY_DOWN) { OOK_NextField(1); } else if (Key == KEY_EXIT) { if (!OOK_Backspace()) gOOKSenderState = OOKSENDER_PROTO_CHOOSE; // EXIT on an empty field } else if (Key == KEY_MENU || Key == KEY_PTT) { OOK_Transmit(); } break; default: break; } gUpdateDisplay = true; }