/* Copyright (C) 2022-2023 Salvatore Sanfilippo -- All Rights Reserved * See the LICENSE file for information about the license. */ #include "app.h" #include "custom_presets.h" #include <flipper_format/flipper_format_i.h> #include <furi_hal_rtc.h> #include <furi_hal_spi.h> #include <furi_hal_interrupt.h> void raw_sampling_timer_start(ProtoViewApp* app); void raw_sampling_timer_stop(ProtoViewApp* app); ProtoViewModulation ProtoViewModulations[] = { {"OOK 650Khz", "FuriHalSubGhzPresetOok650Async", FuriHalSubGhzPresetOok650Async, NULL, 30}, {"OOK 270Khz", "FuriHalSubGhzPresetOok270Async", FuriHalSubGhzPresetOok270Async, NULL, 30}, {"2FSK 2.38Khz", "FuriHalSubGhzPreset2FSKDev238Async", FuriHalSubGhzPreset2FSKDev238Async, NULL, 30}, {"2FSK 47.6Khz", "FuriHalSubGhzPreset2FSKDev476Async", FuriHalSubGhzPreset2FSKDev476Async, NULL, 30}, {"TPMS 1 (FSK)", NULL, 0, (uint8_t*)protoview_subghz_tpms1_fsk_async_regs, 30}, {"TPMS 2 (OOK)", NULL, 0, (uint8_t*)protoview_subghz_tpms2_ook_async_regs, 30}, {"TPMS 3 (GFSK)", NULL, 0, (uint8_t*)protoview_subghz_tpms3_gfsk_async_regs, 30}, {"OOK 40kBaud", NULL, 0, (uint8_t*)protoview_subghz_40k_ook_async_regs, 15}, {"FSK 40kBaud", NULL, 0, (uint8_t*)protoview_subghz_40k_fsk_async_regs, 15}, {NULL, NULL, 0, NULL, 0} /* End of list sentinel. */ }; /* Called after the application initialization in order to setup the * subghz system and put it into idle state. */ void radio_begin(ProtoViewApp* app) { furi_assert(app); furi_hal_subghz_reset(); furi_hal_subghz_idle(); /* Power circuits are noisy. Suppressing the charge while we use * ProtoView will improve the RF performances. */ furi_hal_power_suppress_charge_enter(); /* The CC1101 preset can be either one of the standard presets, if * the modulation "custom" field is NULL, or a custom preset we * defined in custom_presets.h. */ if(ProtoViewModulations[app->modulation].custom == NULL) { furi_hal_subghz_load_preset(ProtoViewModulations[app->modulation].preset); } else { furi_hal_subghz_load_custom_preset(ProtoViewModulations[app->modulation].custom); } furi_hal_gpio_init(furi_hal_subghz.cc1101_g0_pin, GpioModeInput, GpioPullNo, GpioSpeedLow); app->txrx->txrx_state = TxRxStateIDLE; } /* ================================= Reception ============================== */ /* We avoid the subghz provided abstractions and put the data in our * simple abstraction: the RawSamples circular buffer. */ void protoview_rx_callback(bool level, uint32_t duration, void* context) { UNUSED(context); /* Add data to the circular buffer. */ raw_samples_add(RawSamples, level, duration); // FURI_LOG_E(TAG, "FEED: %d %d", (int)level, (int)duration); return; } /* Setup the CC1101 to start receiving using a background worker. */ uint32_t radio_rx(ProtoViewApp* app) { furi_assert(app); if(!furi_hal_subghz_is_frequency_valid(app->frequency)) { furi_crash(TAG " Incorrect RX frequency."); } if(app->txrx->txrx_state == TxRxStateRx) return app->frequency; furi_hal_subghz_idle(); /* Put it into idle state in case it is sleeping. */ uint32_t value = furi_hal_subghz_set_frequency_and_path(app->frequency); FURI_LOG_E(TAG, "Switched to frequency: %lu", value); furi_hal_gpio_init(furi_hal_subghz.cc1101_g0_pin, GpioModeInput, GpioPullNo, GpioSpeedLow); furi_hal_subghz_flush_rx(); furi_hal_subghz_rx(); if(!app->txrx->debug_timer_sampling) { furi_hal_subghz_start_async_rx(protoview_rx_callback, NULL); } else { raw_sampling_worker_start(app); } app->txrx->txrx_state = TxRxStateRx; return value; } /* Stop receiving (if active) and put the radio on idle state. */ void radio_rx_end(ProtoViewApp* app) { furi_assert(app); if(app->txrx->txrx_state == TxRxStateRx) { if(!app->txrx->debug_timer_sampling) { furi_hal_subghz_stop_async_rx(); } else { raw_sampling_worker_stop(app); } } furi_hal_subghz_idle(); app->txrx->txrx_state = TxRxStateIDLE; } /* Put radio on sleep. */ void radio_sleep(ProtoViewApp* app) { furi_assert(app); if(app->txrx->txrx_state == TxRxStateRx) { /* Stop the asynchronous receiving system before putting the * chip into sleep. */ radio_rx_end(app); } furi_hal_subghz_sleep(); app->txrx->txrx_state = TxRxStateSleep; furi_hal_power_suppress_charge_exit(); } /* =============================== Transmission ============================= */ /* This function suspends the current RX state, switches to TX mode, * transmits the signal provided by the callback data_feeder, and later * restores the RX state if there was one. */ void radio_tx_signal(ProtoViewApp* app, FuriHalSubGhzAsyncTxCallback data_feeder, void* ctx) { TxRxState oldstate = app->txrx->txrx_state; if(oldstate == TxRxStateRx) radio_rx_end(app); radio_begin(app); furi_hal_subghz_idle(); uint32_t value = furi_hal_subghz_set_frequency_and_path(app->frequency); FURI_LOG_E(TAG, "Switched to frequency: %lu", value); furi_hal_gpio_write(furi_hal_subghz.cc1101_g0_pin, false); furi_hal_gpio_init( furi_hal_subghz.cc1101_g0_pin, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow); furi_hal_subghz_start_async_tx(data_feeder, ctx); while(!furi_hal_subghz_is_async_tx_complete()) furi_delay_ms(10); furi_hal_subghz_stop_async_tx(); furi_hal_subghz_idle(); radio_begin(app); if(oldstate == TxRxStateRx) radio_rx(app); } /* ============================= Raw sampling mode ============================= * This is a special mode that uses a high frequency timer to sample the * CC1101 pin directly. It's useful for debugging purposes when we want * to get the raw data from the chip and completely bypass the subghz * Flipper system. * ===========================================================================*/ void protoview_timer_isr(void* ctx) { ProtoViewApp* app = ctx; bool level = furi_hal_gpio_read(furi_hal_subghz.cc1101_g0_pin); if(app->txrx->last_g0_value != level) { uint32_t now = DWT->CYCCNT; uint32_t dur = now - app->txrx->last_g0_change_time; dur /= furi_hal_cortex_instructions_per_microsecond(); if(dur > 15000) dur = 15000; raw_samples_add(RawSamples, app->txrx->last_g0_value, dur); app->txrx->last_g0_value = level; app->txrx->last_g0_change_time = now; } LL_TIM_ClearFlag_UPDATE(TIM2); } void raw_sampling_worker_start(ProtoViewApp* app) { UNUSED(app); LL_TIM_InitTypeDef tim_init = { .Prescaler = 63, /* CPU frequency is ~64Mhz. */ .CounterMode = LL_TIM_COUNTERMODE_UP, .Autoreload = 5, /* Sample every 5 us */ }; LL_TIM_Init(TIM2, &tim_init); LL_TIM_SetClockSource(TIM2, LL_TIM_CLOCKSOURCE_INTERNAL); LL_TIM_DisableCounter(TIM2); LL_TIM_SetCounter(TIM2, 0); furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, protoview_timer_isr, app); LL_TIM_EnableIT_UPDATE(TIM2); LL_TIM_EnableCounter(TIM2); FURI_LOG_E(TAG, "Timer enabled"); } void raw_sampling_worker_stop(ProtoViewApp* app) { UNUSED(app); FURI_CRITICAL_ENTER(); LL_TIM_DisableCounter(TIM2); LL_TIM_DisableIT_UPDATE(TIM2); furi_hal_interrupt_set_isr(FuriHalInterruptIdTIM2, NULL, NULL); LL_TIM_DeInit(TIM2); FURI_CRITICAL_EXIT(); }