From 632e841aae537f78b0b17c47054bf6f1157a5989 Mon Sep 17 00:00:00 2001 From: muzkr Date: Fri, 24 Oct 2025 01:31:01 +0800 Subject: [PATCH] SPI flash driver - read --- App/CMakeLists.txt | 5 +- App/app/aircopy.c | 2 +- App/app/fm.c | 2 +- App/app/uart.c | 8 +- App/board.c | 3 +- App/driver/py25q16.c | 209 ++++++++++++++++++++++++++++ App/driver/{storage.c => py25q16.h} | 21 ++- App/main.c | 5 +- App/radio.c | 27 ++-- App/settings.c | 96 +++++++------ App/ui/welcome.c | 8 +- CMakePresets.json | 7 +- 12 files changed, 312 insertions(+), 81 deletions(-) create mode 100644 App/driver/py25q16.c rename App/driver/{storage.c => py25q16.h} (69%) diff --git a/App/CMakeLists.txt b/App/CMakeLists.txt index 7f4220c5..a0959f23 100644 --- a/App/CMakeLists.txt +++ b/App/CMakeLists.txt @@ -9,8 +9,7 @@ target_sources(App INTERFACE # driver/adc.c driver/backlight.c driver/bk4819.c - # driver/eeprom.c - driver/storage.c + driver/py25q16.c driver/gpio.c driver/i2c.c driver/keyboard.c @@ -87,7 +86,7 @@ if(NOT SQL_TONE) endif() target_compile_definitions(App INTERFACE SQL_TONE=${SQL_TONE}) -if(ENABLE_AIRCOPY AND ENABLE_UART) +if(ENABLE_AIRCOPY OR ENABLE_UART) target_sources(App INTERFACE driver/crc.c) endif() diff --git a/App/app/aircopy.c b/App/app/aircopy.c index aa0a85bf..257ccd4c 100644 --- a/App/app/aircopy.c +++ b/App/app/aircopy.c @@ -24,7 +24,7 @@ #include "audio.h" #include "driver/bk4819.h" #include "driver/crc.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "frequencies.h" #include "misc.h" #include "radio.h" diff --git a/App/app/fm.c b/App/app/fm.c index acf302e0..2d669370 100644 --- a/App/app/fm.c +++ b/App/app/fm.c @@ -23,7 +23,7 @@ #include "app/generic.h" #include "audio.h" #include "driver/bk1080.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "driver/gpio.h" #include "functions.h" #include "misc.h" diff --git a/App/app/uart.c b/App/app/uart.c index 5e0c3d20..28b8c87a 100644 --- a/App/app/uart.c +++ b/App/app/uart.c @@ -29,7 +29,7 @@ #include "driver/backlight.h" #include "driver/bk4819.h" #include "driver/crc.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "driver/gpio.h" #include "driver/uart.h" #include "functions.h" @@ -284,8 +284,10 @@ static void CMD_051B(const uint8_t *pBuffer) bLocked = gIsLocked; if (!bLocked) - EEPROM_ReadBuffer(pCmd->Offset, Reply.Data.Data, pCmd->Size); - + { + PY25Q16_ReadBuffer(pCmd->Offset, Reply.Data.Data, pCmd->Size); + } + SendReply(&Reply, pCmd->Size + 8); } diff --git a/App/board.c b/App/board.c index dd28e152..cd9678ef 100644 --- a/App/board.c +++ b/App/board.c @@ -32,7 +32,7 @@ #endif #include "driver/crc.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "driver/flash.h" #include "driver/gpio.h" #include "driver/system.h" @@ -144,6 +144,7 @@ void BOARD_Init(void) BOARD_GPIO_Init(); BACKLIGHT_InitHardware(); BOARD_ADC_Init(); + PY25Q16_Init(); ST7565_Init(); #ifdef ENABLE_FMRADIO BK1080_Init0(); diff --git a/App/driver/py25q16.c b/App/driver/py25q16.c new file mode 100644 index 00000000..a9037c6a --- /dev/null +++ b/App/driver/py25q16.c @@ -0,0 +1,209 @@ +/* Copyright 2023 Dual Tachyon + * https://github.com/DualTachyon + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +#include "driver/py25q16.h" +#include "driver/gpio.h" +#include "py32f071_ll_bus.h" +#include "py32f071_ll_system.h" +#include "py32f071_ll_spi.h" +#include "py32f071_ll_dma.h" +#include "driver/system.h" + +#define SPIx SPI2 +#define CHANNEL_RD LL_DMA_CHANNEL_4 +#define CHANNEL_WR LL_DMA_CHANNEL_5 + +#define CS_PIN GPIO_MAKE_PIN(GPIOA, LL_GPIO_PIN_3) + +static uint8_t TX_Buf[256]; +static volatile bool TC_Flag; + +static inline void CS_Assert() +{ + GPIO_ResetOutputPin(CS_PIN); +} + +static inline void CS_Release() +{ + GPIO_SetOutputPin(CS_PIN); +} + +static void SPI_Init() +{ + LL_APB1_GRP1_EnableClock(LL_APB1_GRP1_PERIPH_SPI2); + LL_AHB1_GRP1_EnableClock(LL_AHB1_GRP1_PERIPH_DMA1); + LL_IOP_GRP1_EnableClock(LL_IOP_GRP1_PERIPH_GPIOA); + + do + { + // SCK: PA0 + // MOSI: PA1 + // MISO: PA2 + + LL_GPIO_InitTypeDef InitStruct; + LL_GPIO_StructInit(&InitStruct); + InitStruct.Mode = LL_GPIO_MODE_ALTERNATE; + InitStruct.Speed = LL_GPIO_SPEED_FREQ_VERY_HIGH; + InitStruct.OutputType = LL_GPIO_OUTPUT_PUSHPULL; + InitStruct.Pull = LL_GPIO_PULL_UP; + + InitStruct.Pin = LL_GPIO_PIN_0; + InitStruct.Alternate = LL_GPIO_AF8_SPI2; + LL_GPIO_Init(GPIOA, &InitStruct); + + InitStruct.Pin = LL_GPIO_PIN_1 | LL_GPIO_PIN_2; + InitStruct.Alternate = LL_GPIO_AF9_SPI2; + LL_GPIO_Init(GPIOA, &InitStruct); + + } while (0); + + LL_SYSCFG_SetDMARemap(DMA1, CHANNEL_RD, LL_SYSCFG_DMA_MAP_SPI2_RD); + LL_SYSCFG_SetDMARemap(DMA1, CHANNEL_WR, LL_SYSCFG_DMA_MAP_SPI2_WR); + + NVIC_SetPriority(DMA1_Channel4_5_6_7_IRQn, 1); + NVIC_EnableIRQ(DMA1_Channel4_5_6_7_IRQn); + + LL_SPI_InitTypeDef InitStruct; + LL_SPI_StructInit(&InitStruct); + InitStruct.Mode = LL_SPI_MODE_MASTER; + InitStruct.TransferDirection = LL_SPI_FULL_DUPLEX; + InitStruct.ClockPhase = LL_SPI_PHASE_2EDGE; + InitStruct.ClockPolarity = LL_SPI_POLARITY_HIGH; + InitStruct.BaudRate = LL_SPI_BAUDRATEPRESCALER_DIV2; + InitStruct.BitOrder = LL_SPI_MSB_FIRST; + InitStruct.NSS = LL_SPI_NSS_SOFT; + InitStruct.CRCCalculation = LL_SPI_CRCCALCULATION_DISABLE; + LL_SPI_Init(SPIx, &InitStruct); + + LL_SPI_Enable(SPIx); +} + +static void SPI_ReadBuf(uint8_t *Buf, uint32_t Size) +{ + LL_SPI_Disable(SPIx); + LL_DMA_DisableChannel(DMA1, CHANNEL_RD); + LL_DMA_DisableChannel(DMA1, CHANNEL_WR); + + LL_DMA_ClearFlag_GI4(DMA1); + + LL_DMA_ConfigTransfer(DMA1, CHANNEL_RD, // + LL_DMA_DIRECTION_PERIPH_TO_MEMORY // + | LL_DMA_MODE_NORMAL // + | LL_DMA_PERIPH_NOINCREMENT // + | LL_DMA_MEMORY_INCREMENT // + | LL_DMA_PDATAALIGN_BYTE // + | LL_DMA_MDATAALIGN_BYTE // + | LL_DMA_PRIORITY_LOW // + ); + + LL_DMA_ConfigTransfer(DMA1, CHANNEL_WR, // + LL_DMA_DIRECTION_MEMORY_TO_PERIPH // + | LL_DMA_MODE_NORMAL // + | LL_DMA_PERIPH_NOINCREMENT // + | LL_DMA_MEMORY_NOINCREMENT // + | LL_DMA_PDATAALIGN_BYTE // + | LL_DMA_MDATAALIGN_BYTE // + | LL_DMA_PRIORITY_LOW // + ); + + LL_DMA_SetMemoryAddress(DMA1, CHANNEL_RD, (uint32_t)Buf); + LL_DMA_SetPeriphAddress(DMA1, CHANNEL_RD, LL_SPI_DMA_GetRegAddr(SPIx)); + LL_DMA_SetDataLength(DMA1, CHANNEL_RD, Size); + + LL_DMA_SetMemoryAddress(DMA1, CHANNEL_WR, (uint32_t)TX_Buf); + LL_DMA_SetPeriphAddress(DMA1, CHANNEL_WR, LL_SPI_DMA_GetRegAddr(SPIx)); + LL_DMA_SetDataLength(DMA1, CHANNEL_WR, Size); + + TC_Flag = false; + LL_DMA_EnableIT_TC(DMA1, CHANNEL_RD); + LL_DMA_EnableChannel(DMA1, CHANNEL_RD); + LL_DMA_EnableChannel(DMA1, CHANNEL_WR); + + LL_SPI_EnableDMAReq_RX(SPIx); + LL_SPI_Enable(SPIx); + LL_SPI_EnableDMAReq_TX(SPIx); + + while (!TC_Flag) + ; +} + +static uint8_t SPI_WriteByte(uint8_t Value) +{ + while (!LL_SPI_IsActiveFlag_TXE(SPIx)) + ; + LL_SPI_TransmitData8(SPIx, Value); + while (!LL_SPI_IsActiveFlag_RXNE(SPIx)) + ; + return LL_SPI_ReceiveData8(SPIx); +} + +void PY25Q16_Init() +{ + CS_Release(); + SPI_Init(); +} + +void PY25Q16_ReadBuffer(uint32_t Address, void *pBuffer, uint32_t Size) +{ + CS_Assert(); + + SPI_WriteByte(0x03); // Fast read + SPI_WriteByte(0xff & (Address >> 16)); + SPI_WriteByte(0xff & (Address >> 8)); + SPI_WriteByte(0xff & Address); + + if (Size >= 16) + { + SPI_ReadBuf((uint8_t *)pBuffer, Size); + } + else + { + for (uint32_t i = 0; i < Size; i++) + { + ((uint8_t *)(pBuffer))[i] = SPI_WriteByte(0xff); + } + } + + CS_Release(); +} + +void PY25Q16_WriteBuffer(uint16_t Address, const void *pBuffer) +{ +} + +void DMA1_Channel4_5_6_7_IRQHandler() +{ + if (LL_DMA_IsActiveFlag_TC4(DMA1) && LL_DMA_IsEnabledIT_TC(DMA1, CHANNEL_RD)) + { + LL_DMA_DisableIT_TC(DMA1, CHANNEL_RD); + LL_DMA_ClearFlag_TC4(DMA1); + + while (LL_SPI_TX_FIFO_EMPTY != LL_SPI_GetTxFIFOLevel(SPIx)) + ; + while (LL_SPI_IsActiveFlag_BSY(SPIx)) + ; + while (LL_SPI_RX_FIFO_EMPTY != LL_SPI_GetRxFIFOLevel(SPIx)) + ; + + LL_SPI_DisableDMAReq_TX(SPIx); + LL_SPI_DisableDMAReq_RX(SPIx); + + TC_Flag = true; + } +} diff --git a/App/driver/storage.c b/App/driver/py25q16.h similarity index 69% rename from App/driver/storage.c rename to App/driver/py25q16.h index 81a8d538..b35e7a5e 100644 --- a/App/driver/storage.c +++ b/App/driver/py25q16.h @@ -14,18 +14,15 @@ * limitations under the License. */ -#include -#include +#ifndef DRIVER_PY25Q16_H +#define DRIVER_PY25Q16_H -#include "driver/eeprom.h" -#include "driver/system.h" +#include -void EEPROM_ReadBuffer(uint16_t Address, void *pBuffer, uint8_t Size) -{ - -} +void PY25Q16_Init(); +void PY25Q16_ReadBuffer(uint32_t Address, void *pBuffer, uint32_t Size); +void PY25Q16_WriteBuffer(uint16_t Address, const void *pBuffer); -void EEPROM_WriteBuffer(uint16_t Address, const void *pBuffer) -{ - -} +#define EEPROM_WriteBuffer PY25Q16_WriteBuffer + +#endif diff --git a/App/main.c b/App/main.c index f4ebf816..094055a8 100644 --- a/App/main.c +++ b/App/main.c @@ -48,7 +48,7 @@ #include "driver/gpio.h" #include "driver/system.h" #include "driver/systick.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #ifdef ENABLE_UART #include "driver/uart.h" #endif @@ -59,6 +59,9 @@ #include "ui/lock.h" #include "ui/welcome.h" #include "ui/menu.h" + +#include "external/printf/printf.h" + void _putchar(__attribute__((unused)) char c) { diff --git a/App/radio.c b/App/radio.c index 08a7e302..3c0b9eac 100644 --- a/App/radio.c +++ b/App/radio.c @@ -25,7 +25,7 @@ #include "audio.h" #include "dcs.h" #include "driver/bk4819.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "driver/gpio.h" #include "driver/system.h" #include "frequencies.h" @@ -240,11 +240,11 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure pVfo->SCANLIST3_PARTICIPATION = bParticipation3; pVfo->CHANNEL_SAVE = channel; - uint16_t base; + uint32_t base; if (IS_MR_CHANNEL(channel)) base = channel * 16; else - base = 0x0C80 + ((channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16); + base = 0x001000 + ((channel - FREQ_CHANNEL_FIRST) * 32) + (VFO * 16); if (configure == VFO_CONFIGURE_RELOAD || IS_FREQ_CHANNEL(channel)) { @@ -253,7 +253,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure // *************** - EEPROM_ReadBuffer(base + 8, data, sizeof(data)); + PY25Q16_ReadBuffer(base + 8, data, sizeof(data)); tmp = data[3] & 0x0F; if (tmp > TX_OFFSET_FREQUENCY_DIRECTION_SUB) @@ -366,7 +366,7 @@ void RADIO_ConfigureChannel(const unsigned int VFO, const unsigned int configure uint32_t Frequency; uint32_t Offset; } __attribute__((packed)) info; - EEPROM_ReadBuffer(base, &info, sizeof(info)); + PY25Q16_ReadBuffer(base, &info, sizeof(info)); if(info.Frequency==0xFFFFFFFF) pVfo->freq_config_RX.Frequency = frequencyBandTable[band].lower; else @@ -449,7 +449,8 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo) // squelch FREQUENCY_Band_t Band = FREQUENCY_GetBand(pInfo->pRX->Frequency); - uint16_t Base = (Band < BAND4_174MHz) ? 0x1E60 : 0x1E00; + // 0x1E60 : 0x1E00 + uint32_t Base = (Band < BAND4_174MHz) ? 0x010060 : 0x010000; if (gEeprom.SQUELCH_LEVEL == 0) { // squelch == 0 (off) @@ -465,14 +466,14 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo) { // squelch >= 1 Base += gEeprom.SQUELCH_LEVEL; // my eeprom squelch-1 // VHF UHF - EEPROM_ReadBuffer(Base + 0x00, &pInfo->SquelchOpenRSSIThresh, 1); // 50 10 - EEPROM_ReadBuffer(Base + 0x10, &pInfo->SquelchCloseRSSIThresh, 1); // 40 5 + PY25Q16_ReadBuffer(Base + 0x00, &pInfo->SquelchOpenRSSIThresh, 1); // 50 10 + PY25Q16_ReadBuffer(Base + 0x10, &pInfo->SquelchCloseRSSIThresh, 1); // 40 5 - EEPROM_ReadBuffer(Base + 0x20, &pInfo->SquelchOpenNoiseThresh, 1); // 65 90 - EEPROM_ReadBuffer(Base + 0x30, &pInfo->SquelchCloseNoiseThresh, 1); // 70 100 + PY25Q16_ReadBuffer(Base + 0x20, &pInfo->SquelchOpenNoiseThresh, 1); // 65 90 + PY25Q16_ReadBuffer(Base + 0x30, &pInfo->SquelchCloseNoiseThresh, 1); // 70 100 - EEPROM_ReadBuffer(Base + 0x40, &pInfo->SquelchCloseGlitchThresh, 1); // 90 90 - EEPROM_ReadBuffer(Base + 0x50, &pInfo->SquelchOpenGlitchThresh, 1); // 100 100 + PY25Q16_ReadBuffer(Base + 0x40, &pInfo->SquelchCloseGlitchThresh, 1); // 90 90 + PY25Q16_ReadBuffer(Base + 0x50, &pInfo->SquelchOpenGlitchThresh, 1); // 100 100 uint16_t noise_open = pInfo->SquelchOpenNoiseThresh; @@ -551,7 +552,7 @@ void RADIO_ConfigureSquelchAndOutputPower(VFO_Info_t *pInfo) currentPower--; } - EEPROM_ReadBuffer(0x1ED0 + (Band * 16) + (Op * 3), Txp, 3); + PY25Q16_ReadBuffer(0x1ED0 + (Band * 16) + (Op * 3), Txp, 3); #ifdef ENABLE_FEAT_F4HWN // make low and mid even lower diff --git a/App/settings.c b/App/settings.c index 6741b136..cfae4868 100644 --- a/App/settings.c +++ b/App/settings.c @@ -22,7 +22,7 @@ #endif #include "driver/bk1080.h" #include "driver/bk4819.h" -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "misc.h" #include "settings.h" #include "ui/menu.h" @@ -44,7 +44,7 @@ void SETTINGS_InitEEPROM(void) { uint8_t Data[16] = {0}; // 0E70..0E77 - EEPROM_ReadBuffer(0x0E70, Data, 8); + PY25Q16_ReadBuffer(0x004000, Data, 8); gEeprom.CHAN_1_CALL = IS_MR_CHANNEL(Data[0]) ? Data[0] : MR_CHANNEL_FIRST; gEeprom.SQUELCH_LEVEL = (Data[1] < 10) ? Data[1] : 1; gEeprom.TX_TIMEOUT_TIMER = (Data[2] > 4 && Data[2] < 180) ? Data[2] : 11; @@ -65,7 +65,7 @@ void SETTINGS_InitEEPROM(void) gEeprom.MIC_SENSITIVITY = (Data[7] < 5) ? Data[7] : 4; // 0E78..0E7F - EEPROM_ReadBuffer(0x0E78, Data, 8); + PY25Q16_ReadBuffer(0x004008, Data, 8); gEeprom.BACKLIGHT_MAX = (Data[0] & 0xF) <= 10 ? (Data[0] & 0xF) : 10; gEeprom.BACKLIGHT_MIN = (Data[0] >> 4) < gEeprom.BACKLIGHT_MAX ? (Data[0] >> 4) : 0; #ifdef ENABLE_BLMIN_TMP_OFF @@ -92,7 +92,7 @@ void SETTINGS_InitEEPROM(void) #endif // 0E80..0E87 - EEPROM_ReadBuffer(0x0E80, Data, 8); + PY25Q16_ReadBuffer(0x005000, Data, 8); gEeprom.ScreenChannel[0] = IS_VALID_CHANNEL(Data[0]) ? Data[0] : (FREQ_CHANNEL_FIRST + BAND6_400MHz); gEeprom.ScreenChannel[1] = IS_VALID_CHANNEL(Data[3]) ? Data[3] : (FREQ_CHANNEL_FIRST + BAND6_400MHz); gEeprom.MrChannel[0] = IS_MR_CHANNEL(Data[1]) ? Data[1] : MR_CHANNEL_FIRST; @@ -114,7 +114,7 @@ void SETTINGS_InitEEPROM(void) uint8_t band:2; //uint8_t space:2; } __attribute__((packed)) fmCfg; - EEPROM_ReadBuffer(0x0E88, &fmCfg, 4); + PY25Q16_ReadBuffer(0x006000, &fmCfg, 4); gEeprom.FM_Band = fmCfg.band; //gEeprom.FM_Space = fmCfg.space; @@ -127,12 +127,12 @@ void SETTINGS_InitEEPROM(void) } // 0E40..0E67 - EEPROM_ReadBuffer(0x0E40, gFM_Channels, sizeof(gFM_Channels)); + PY25Q16_ReadBuffer(0x003000, gFM_Channels, sizeof(gFM_Channels)); FM_ConfigureChannelState(); #endif // 0E90..0E97 - EEPROM_ReadBuffer(0x0E90, Data, 8); + PY25Q16_ReadBuffer(0x007000, Data, 8); gEeprom.BEEP_CONTROL = Data[0] & 1; gEeprom.KEY_M_LONG_PRESS_ACTION = ((Data[0] >> 1) < ACTION_OPT_LEN) ? (Data[0] >> 1) : ACTION_OPT_NONE; gEeprom.KEY_1_SHORT_PRESS_ACTION = (Data[1] < ACTION_OPT_LEN) ? Data[1] : ACTION_OPT_MONITOR; @@ -149,12 +149,12 @@ void SETTINGS_InitEEPROM(void) // 0E98..0E9F #ifdef ENABLE_PWRON_PASSWORD - EEPROM_ReadBuffer(0x0E98, Data, 8); + PY25Q16_ReadBuffer(0x007000 + 0x8, Data, 8); memcpy(&gEeprom.POWER_ON_PASSWORD, Data, 4); #endif // 0EA0..0EA7 - EEPROM_ReadBuffer(0x0EA0, Data, 8); + PY25Q16_ReadBuffer(0x007000 + 0x10, Data, 8); #ifdef ENABLE_VOICE gEeprom.VOICE_PROMPT = (Data[0] < 3) ? Data[0] : VOICE_PROMPT_ENGLISH; #endif @@ -170,7 +170,7 @@ void SETTINGS_InitEEPROM(void) #endif // 0EA8..0EAF - EEPROM_ReadBuffer(0x0EA8, Data, 8); + PY25Q16_ReadBuffer(0x007000 + 0x18, Data, 8); #ifdef ENABLE_ALARM gEeprom.ALARM_MODE = (Data[0] < 2) ? Data[0] : true; #endif @@ -180,7 +180,7 @@ void SETTINGS_InitEEPROM(void) gEeprom.BATTERY_TYPE = (Data[4] < BATTERY_TYPE_UNKNOWN) ? Data[4] : BATTERY_TYPE_1600_MAH; // 0ED0..0ED7 - EEPROM_ReadBuffer(0x0ED0, Data, 8); + PY25Q16_ReadBuffer(0x007000 + 0x40, Data, 8); gEeprom.DTMF_SIDE_TONE = (Data[0] < 2) ? Data[0] : true; #ifdef ENABLE_DTMF_CALLING @@ -194,7 +194,7 @@ void SETTINGS_InitEEPROM(void) gEeprom.DTMF_HASH_CODE_PERSIST_TIME = (Data[7] < 101) ? Data[7] * 10 : 100; // 0ED8..0EDF - EEPROM_ReadBuffer(0x0ED8, Data, 8); + PY25Q16_ReadBuffer(0x007000 + 0x48, Data, 8); gEeprom.DTMF_CODE_PERSIST_TIME = (Data[0] < 101) ? Data[0] * 10 : 100; gEeprom.DTMF_CODE_INTERVAL_TIME = (Data[1] < 101) ? Data[1] * 10 : 100; #ifdef ENABLE_DTMF_CALLING @@ -202,7 +202,7 @@ void SETTINGS_InitEEPROM(void) // 0EE0..0EE7 - EEPROM_ReadBuffer(0x0EE0, Data, sizeof(gEeprom.ANI_DTMF_ID)); + PY25Q16_ReadBuffer(0x008000, Data, sizeof(gEeprom.ANI_DTMF_ID)); if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.ANI_DTMF_ID))) { memcpy(gEeprom.ANI_DTMF_ID, Data, sizeof(gEeprom.ANI_DTMF_ID)); } else { @@ -211,7 +211,7 @@ void SETTINGS_InitEEPROM(void) // 0EE8..0EEF - EEPROM_ReadBuffer(0x0EE8, Data, sizeof(gEeprom.KILL_CODE)); + PY25Q16_ReadBuffer(0x008000 + 0x8, Data, sizeof(gEeprom.KILL_CODE)); if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.KILL_CODE))) { memcpy(gEeprom.KILL_CODE, Data, sizeof(gEeprom.KILL_CODE)); } else { @@ -219,7 +219,7 @@ void SETTINGS_InitEEPROM(void) } // 0EF0..0EF7 - EEPROM_ReadBuffer(0x0EF0, Data, sizeof(gEeprom.REVIVE_CODE)); + PY25Q16_ReadBuffer(0x008000 + 0x10, Data, sizeof(gEeprom.REVIVE_CODE)); if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.REVIVE_CODE))) { memcpy(gEeprom.REVIVE_CODE, Data, sizeof(gEeprom.REVIVE_CODE)); } else { @@ -228,7 +228,7 @@ void SETTINGS_InitEEPROM(void) #endif // 0EF8..0F07 - EEPROM_ReadBuffer(0x0EF8, Data, sizeof(gEeprom.DTMF_UP_CODE)); + PY25Q16_ReadBuffer(0x008000 + 0x18, Data, sizeof(gEeprom.DTMF_UP_CODE)); if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.DTMF_UP_CODE))) { memcpy(gEeprom.DTMF_UP_CODE, Data, sizeof(gEeprom.DTMF_UP_CODE)); } else { @@ -236,7 +236,7 @@ void SETTINGS_InitEEPROM(void) } // 0F08..0F17 - EEPROM_ReadBuffer(0x0F08, Data, sizeof(gEeprom.DTMF_DOWN_CODE)); + PY25Q16_ReadBuffer(0x008000 + 0x28, Data, sizeof(gEeprom.DTMF_DOWN_CODE)); if (DTMF_ValidateCodes((char *)Data, sizeof(gEeprom.DTMF_DOWN_CODE))) { memcpy(gEeprom.DTMF_DOWN_CODE, Data, sizeof(gEeprom.DTMF_DOWN_CODE)); } else { @@ -244,7 +244,7 @@ void SETTINGS_InitEEPROM(void) } // 0F18..0F1F - EEPROM_ReadBuffer(0x0F18, Data, 8); + PY25Q16_ReadBuffer(0x009000, Data, 8); gEeprom.SCAN_LIST_DEFAULT = (Data[0] < 6) ? Data[0] : 0; // we now have 'all' channel scan option // Fake data @@ -277,7 +277,7 @@ void SETTINGS_InitEEPROM(void) } // 0F40..0F47 - EEPROM_ReadBuffer(0x0F40, Data, 8); + PY25Q16_ReadBuffer(0x00b000, Data, 8); gSetting_F_LOCK = (Data[0] < F_LOCK_LEN) ? Data[0] : F_LOCK_DEF; #ifndef ENABLE_FEAT_F4HWN gSetting_350TX = (Data[1] < 2) ? Data[1] : false; // was true @@ -316,7 +316,7 @@ void SETTINGS_InitEEPROM(void) } // 0D60..0E27 - EEPROM_ReadBuffer(0x0D60, gMR_ChannelAttributes, sizeof(gMR_ChannelAttributes)); + PY25Q16_ReadBuffer(0x002000, gMR_ChannelAttributes, sizeof(gMR_ChannelAttributes)); for(uint16_t i = 0; i < sizeof(gMR_ChannelAttributes); i++) { ChannelAttributes_t *att = &gMR_ChannelAttributes[i]; if(att->__val == 0xff){ @@ -327,7 +327,7 @@ void SETTINGS_InitEEPROM(void) } // 0F30..0F3F - EEPROM_ReadBuffer(0x0F30, gCustomAesKey, sizeof(gCustomAesKey)); + PY25Q16_ReadBuffer(0x00a000, gCustomAesKey, sizeof(gCustomAesKey)); bHasCustomAesKey = false; #ifndef ENABLE_FEAT_F4HWN for (unsigned int i = 0; i < ARRAY_SIZE(gCustomAesKey); i++) @@ -342,7 +342,8 @@ void SETTINGS_InitEEPROM(void) #ifdef ENABLE_FEAT_F4HWN // 1FF0..0x1FF7 - EEPROM_ReadBuffer(0x1FF0, Data, 8); + // TODO: address TBD + PY25Q16_ReadBuffer(0x00c000, Data, 8); gSetting_set_pwr = (((Data[7] & 0xF0) >> 4) < 7) ? ((Data[7] & 0xF0) >> 4) : 0; gSetting_set_ptt = (((Data[7] & 0x0F)) < 2) ? ((Data[7] & 0x0F)) : 0; @@ -398,16 +399,19 @@ void SETTINGS_LoadCalibration(void) { // uint8_t Mic; - EEPROM_ReadBuffer(0x1EC0, gEEPROM_RSSI_CALIB[3], 8); + // 0x1EC0 + PY25Q16_ReadBuffer(0x010000 + 0xc0, gEEPROM_RSSI_CALIB[3], 8); memcpy(gEEPROM_RSSI_CALIB[4], gEEPROM_RSSI_CALIB[3], 8); memcpy(gEEPROM_RSSI_CALIB[5], gEEPROM_RSSI_CALIB[3], 8); memcpy(gEEPROM_RSSI_CALIB[6], gEEPROM_RSSI_CALIB[3], 8); - EEPROM_ReadBuffer(0x1EC8, gEEPROM_RSSI_CALIB[0], 8); + // 0x1EC8 + PY25Q16_ReadBuffer(0x010000 + 0xc8, gEEPROM_RSSI_CALIB[0], 8); memcpy(gEEPROM_RSSI_CALIB[1], gEEPROM_RSSI_CALIB[0], 8); memcpy(gEEPROM_RSSI_CALIB[2], gEEPROM_RSSI_CALIB[0], 8); - EEPROM_ReadBuffer(0x1F40, gBatteryCalibration, 12); + // 0x1F40 + PY25Q16_ReadBuffer(0x010000 + 0x140, gBatteryCalibration, 12); if (gBatteryCalibration[0] >= 5000) { gBatteryCalibration[0] = 1900; @@ -416,11 +420,13 @@ void SETTINGS_LoadCalibration(void) gBatteryCalibration[5] = 2300; #ifdef ENABLE_VOX - EEPROM_ReadBuffer(0x1F50 + (gEeprom.VOX_LEVEL * 2), &gEeprom.VOX1_THRESHOLD, 2); - EEPROM_ReadBuffer(0x1F68 + (gEeprom.VOX_LEVEL * 2), &gEeprom.VOX0_THRESHOLD, 2); + // 0x1F50 + PY25Q16_ReadBuffer(0x010000 + 0x150 + (gEeprom.VOX_LEVEL * 2), &gEeprom.VOX1_THRESHOLD, 2); + // 0x1F68 + PY25Q16_ReadBuffer(0x010000 + 0x168 + (gEeprom.VOX_LEVEL * 2), &gEeprom.VOX0_THRESHOLD, 2); #endif - //EEPROM_ReadBuffer(0x1F80 + gEeprom.MIC_SENSITIVITY, &Mic, 1); + //PY25Q16_ReadBuffer(0x1F80 + gEeprom.MIC_SENSITIVITY, &Mic, 1); //gEeprom.MIC_SENSITIVITY_TUNING = (Mic < 32) ? Mic : 15; gEeprom.MIC_SENSITIVITY_TUNING = gMicGain_dB2[gEeprom.MIC_SENSITIVITY]; @@ -436,7 +442,8 @@ void SETTINGS_LoadCalibration(void) // radio 1 .. 04 00 46 00 50 00 2C 0E // radio 2 .. 05 00 46 00 50 00 2C 0E - EEPROM_ReadBuffer(0x1F88, &Misc, 8); + // 0x1F88 + PY25Q16_ReadBuffer(0x010000 + 0x188, &Misc, 8); gEeprom.BK4819_XTAL_FREQ_LOW = (Misc.BK4819_XtalFreqLow >= -1000 && Misc.BK4819_XtalFreqLow <= 1000) ? Misc.BK4819_XtalFreqLow : 0; gEEPROM_1F8A = Misc.EEPROM_1F8A & 0x01FF; @@ -461,7 +468,7 @@ uint32_t SETTINGS_FetchChannelFrequency(const int channel) uint32_t offset; } __attribute__((packed)) info; - EEPROM_ReadBuffer(channel * 16, &info, sizeof(info)); + PY25Q16_ReadBuffer(channel * 16, &info, sizeof(info)); return info.frequency; } @@ -479,7 +486,8 @@ void SETTINGS_FetchChannelName(char *s, const int channel) if (!RADIO_CheckValidChannel(channel, false, 0)) return; - EEPROM_ReadBuffer(0x0F50 + (channel * 16), s, 10); + // 0x0F50 + PY25Q16_ReadBuffer(0x00e000 + (channel * 16), s, 10); int i; for (i = 0; i < 10; i++) @@ -576,7 +584,8 @@ void SETTINGS_SaveVfoIndices(void) uint8_t State[8]; #ifndef ENABLE_NOAA - EEPROM_ReadBuffer(0x0E80, State, sizeof(State)); + // 0x0E80 + PY25Q16_ReadBuffer(0x005000, State, sizeof(State)); #endif State[0] = gEeprom.ScreenChannel[0]; @@ -778,7 +787,9 @@ void SETTINGS_SaveSettings(void) EEPROM_WriteBuffer(0x0F40, State); #ifdef ENABLE_FEAT_F4HWN - EEPROM_ReadBuffer(0x1FF0, State, sizeof(State)); + // 0x1FF0 + // TODO: TBD + PY25Q16_ReadBuffer(0x00c000, State, sizeof(State)); //memset(State, 0xFF, sizeof(State)); @@ -894,7 +905,8 @@ void SETTINGS_SaveBatteryCalibration(const uint16_t * batteryCalibration) { uint16_t buf[4]; EEPROM_WriteBuffer(0x1F40, batteryCalibration); - EEPROM_ReadBuffer( 0x1F48, buf, sizeof(buf)); + // 0x1F48 + PY25Q16_ReadBuffer(0x010000 + 0x148, buf, sizeof(buf)); buf[0] = batteryCalibration[4]; buf[1] = batteryCalibration[5]; EEPROM_WriteBuffer(0x1F48, buf); @@ -924,8 +936,9 @@ void SETTINGS_UpdateChannel(uint8_t channel, const VFO_Info_t *pVFO, bool keep, .scanlist3 = 0, }; // default attributes - uint16_t offset = 0x0D60 + (channel & ~7u); - EEPROM_ReadBuffer(offset, state, sizeof(state)); + // 0x0D60 + uint16_t offset = 0x002000 + (channel & ~7u); + PY25Q16_ReadBuffer(offset, state, sizeof(state)); if (keep) { att.band = pVFO->Band; @@ -964,7 +977,8 @@ void SETTINGS_WriteBuildOptions(void) uint8_t State[8]; #ifdef ENABLE_FEAT_F4HWN - EEPROM_ReadBuffer(0x1FF0, State, sizeof(State)); + // 0x1FF0 + PY25Q16_ReadBuffer(0x00c000, State, sizeof(State)); #endif State[0] = 0 @@ -1024,7 +1038,8 @@ State[1] = 0 void SETTINGS_WriteCurrentState(void) { uint8_t State[8]; - EEPROM_ReadBuffer(0x0E78, State, sizeof(State)); + // 0x0E78 + PY25Q16_ReadBuffer(0x004000 + 0x8, State, sizeof(State)); //State[3] = (gEeprom.CURRENT_STATE << 4) | (gEeprom.BATTERY_SAVE & 0x0F); State[7] = (gEeprom.VFO_OPEN & 0x01) | ((gEeprom.CURRENT_STATE & 0x07) << 1) | ((gEeprom.SCAN_LIST_DEFAULT & 0x07) << 4); EEPROM_WriteBuffer(0x0E78, State); @@ -1035,7 +1050,8 @@ State[1] = 0 void SETTINGS_WriteCurrentVol(void) { uint8_t State[8]; - EEPROM_ReadBuffer(0x1F88, State, sizeof(State)); + // 0x1F88 + PY25Q16_ReadBuffer(0x010000 + 0x188, State, sizeof(State)); State[6] = gEeprom.VOLUME_GAIN; EEPROM_WriteBuffer(0x1F88, State); } @@ -1048,7 +1064,7 @@ void SETTINGS_ResetTxLock(void) for(uint8_t channel = 0; channel < 200; channel++) { uint16_t OffsetVFO = channel * 16; - EEPROM_ReadBuffer(OffsetVFO + 8, State, sizeof(State)); + PY25Q16_ReadBuffer(OffsetVFO + 8, State, sizeof(State)); State[4] |= (1 << 6); EEPROM_WriteBuffer(OffsetVFO + 8, State); } diff --git a/App/ui/welcome.c b/App/ui/welcome.c index d85f339b..d47fd7cf 100644 --- a/App/ui/welcome.c +++ b/App/ui/welcome.c @@ -16,7 +16,7 @@ #include -#include "driver/eeprom.h" +#include "driver/py25q16.h" #include "driver/st7565.h" #include "external/printf/printf.h" #include "helper/battery.h" @@ -75,8 +75,10 @@ void UI_DisplayWelcome(void) memset(WelcomeString0, 0, sizeof(WelcomeString0)); memset(WelcomeString1, 0, sizeof(WelcomeString1)); - EEPROM_ReadBuffer(0x0EB0, WelcomeString0, 16); - EEPROM_ReadBuffer(0x0EC0, WelcomeString1, 16); + // 0x0EB0 + PY25Q16_ReadBuffer(0x007020, WelcomeString0, 16); + // 0x0EC0 + PY25Q16_ReadBuffer(0x007030, WelcomeString1, 16); sprintf(WelcomeString2, "%u.%02uV %u%%", gBatteryVoltageAverage / 100, diff --git a/CMakePresets.json b/CMakePresets.json index de5687b3..0055df94 100644 --- a/CMakePresets.json +++ b/CMakePresets.json @@ -66,16 +66,17 @@ "ENABLE_AM_FIX_SHOW_DATA": false, "ENABLE_AGC_SHOW_DATA": false, "ENABLE_UART_RW_BK_REGS": false, - "ENABLE_SWD": true, + "ENABLE_SWD": false, "VERSION_STRING_1": "v0.22", "VERSION_STRING_2": "v4.2" } }, { "name": "Custom", - "inherits": "default", + "inherits": "Broadcast", "cacheVariables": { - "ENABLE_FEAT_F4HWN": true + "ENABLE_SWD": true, + "ENABLE_AIRCOPY": false } }, {