Templates/STM32_MemorySPI
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

merge into: Templates:bare_memspi
Branches Tags
Templates:release Templates:develop Templates:bare_memspi Templates:example
...
pull from: Templates:example
Branches Tags
Templates:develop Templates:release Templates:bare_memspi Templates:example

2 Commits
bare_memsp ... example

Author SHA1 Message Date
alexey
7133e63633 Добавлены проверки на режим прерывания (пока ниче не работает) 2024-08-14 18:28:35 +03:00
alexey
fd7d230e10 Начало работы над прерываниями 2024-08-14 18:27:50 +03:00
7 changed files with 733 additions and 104 deletions
Expand all files Collapse all files

96
CubeKeil Example/Core/Src/main.c
View File

@@ -65,14 +65,20 @@ MEMSPI_WriteInitTypeDef MCUFlashToExternalFlashInit;
uint8_t read_buff[20] = {0}; uint8_t read_buff[20] = {0};
// what writting in examples in while(1) // what writting in examples in while(1)
uint8_t write_buff[20] = {0x14,0x13,0x12,0x11,0x10, uint8_t write_buff[20] = {0x14,0x13,0x12,0x11,0x10,
0x0F,0x0E,0x0D,0x0C,0x0B, 0x0F,0x0E,0x0D,0x0C,0x0B,
0x0A,0x09,0x08,0x07,0x06, 0x0A,0x09,0x08,0x07,0x06,
0x05,0x04,0x03,0x02,0x01}; 0x05,0x04,0x03,0x02,0x01};
uint32_t FLASH_write = 0; // where start writting (except MCU App - MCU App writing on 0x0) uint32_t FLASH_write = 0x1000; // where start writting (except MCU App - MCU App writing on 0x0)
uint32_t FLASH_mcu_size = 0x2000; // how many bytes from app write to flash uint32_t FLASH_mcu_size = 0x2000; // how many bytes from app write to flash
uint32_t FLASH_read = 0x100; // where read uint32_t FLASH_read = 0x1100; // where read
uint32_t Timeout = 1000; // timeout for examples in while(1) uint32_t Timeout = 1000; // timeout for examples in while(1)
void SPI2_IRQHandler(void)
{
MEMSPI_Handler(&hmemspi);
}
/* USER CODE END 0 */ /* USER CODE END 0 */
/** /**
@@ -107,16 +113,16 @@ int main(void)
MX_RNG_Init(); MX_RNG_Init();
/* USER CODE BEGIN 2 */ /* USER CODE BEGIN 2 */
// FLASH MEMSPI INIT // FLASH MEMSPI INIT
hmemspi.hspi.Instance = SPI2; hmemspi.sspi.hspi.Instance = SPI2;
hmemspi.hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128; hmemspi.sspi.hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;
hmemspi.GPIOs.CS_GPIOx = GPIOA; hmemspi.CS_GPIOx = GPIOA;
hmemspi.GPIOs.CS_PIN = GPIO_PIN_4; hmemspi.CS_PIN = GPIO_PIN_4;
hmemspi.GPIOs.CLK_GPIOx = GPIOB; hmemspi.sspi.CLK_GPIOx = GPIOB;
hmemspi.GPIOs.CLK_PIN = GPIO_PIN_13; hmemspi.sspi.CLK_PIN = GPIO_PIN_13;
hmemspi.GPIOs.MISO_GPIOx = GPIOC; hmemspi.sspi.MISO_GPIOx = GPIOB;
hmemspi.GPIOs.MISO_PIN = GPIO_PIN_2; hmemspi.sspi.MISO_PIN = GPIO_PIN_14;
hmemspi.GPIOs.MOSI_GPIOx = GPIOC; hmemspi.sspi.MOSI_GPIOx = GPIOB;
hmemspi.GPIOs.MOSI_PIN = GPIO_PIN_3; hmemspi.sspi.MOSI_PIN = GPIO_PIN_15;
MEMSPI_Base_Init(&hmemspi); MEMSPI_Base_Init(&hmemspi);
/* USER CODE END 2 */ /* USER CODE END 2 */
@@ -124,48 +130,68 @@ int main(void)
/* Infinite loop */ /* Infinite loop */
/* USER CODE BEGIN WHILE */ /* USER CODE BEGIN WHILE */
// Example for FLASH: using manufactire info CMD // Example for FLASH (interrupt): using manufactire info CMD
uint32_t memspi_ID = MEMSPI_CMD_Read_JEDEC_ID(&hmemspi, 100); uint32_t memspi_ID;
uint64_t memspi_unique_ID = MEMSPI_CMD_Read_Device_ID(&hmemspi, 100); uint64_t memspi_unique_ID;
#ifdef EXT_FLASH MEMSPI_CMD_Read_JEDEC_ID_IT(&hmemspi, &memspi_ID);
// Example fpr FLASH: writting MCU Program to external FLASH HAL_Delay(100);
writeInit.fSavePrevoisData = 1; MEMSPI_CMD_Read_Device_ID_IT(&hmemspi, &memspi_unique_ID);
writeInit.pDataPtr = write_buff; HAL_Delay(100);
writeInit.Data_Address = 0xfb;
writeInit.Data_Size = 1;
writeInit.Sector_Address = 0xf9;
writeInit.Sector_Size = 15;
// Example for FLASH (interrupt/blocking): erase/program/read functions
// writting on two pages:
// writing 15 bytes at 0xf9 - its writting 7 bytes at first page, and 8 bytes at second page
MEMSPI_RES = MEMSPI_FLASH_Erase(&hmemspi, 0, 1, 1000, 100);
MEMSPI_RES = MEMSPI_FLASH_Program(&hmemspi, 0xf9, write_buff, 15, 100, 1);
MEMSPI_RES = MEMSPI_Read_Memory_IT(&hmemspi, 0xf9, read_buff, 15);
MEMSPI_WaitOnFlagsUntilTimeout(&hmemspi, MEMSPI_SR_BUSY, 0, NULL, NULL);
// Example for FLASH (blocking): using manufactire info CMD
memspi_ID = MEMSPI_CMD_Read_JEDEC_ID(&hmemspi, 100);
memspi_unique_ID = MEMSPI_CMD_Read_Device_ID(&hmemspi, 100);
MEMSPI_RES = MEMSPI_CMD_Write_Status_Register(&hmemspi, 0, 100);
#ifdef EXT_FLASH
// Example fpr FLASH (blocking): writting MCU Program to external FLASH
MCUFlashToExternalFlashInit.pDataPtr = (uint8_t *)FLASH_BASE; MCUFlashToExternalFlashInit.pDataPtr = (uint8_t *)FLASH_BASE;
MCUFlashToExternalFlashInit.Data_Address = 0; MCUFlashToExternalFlashInit.Data_Address = FLASH_write;
MCUFlashToExternalFlashInit.Data_Size = FLASH_mcu_size; MCUFlashToExternalFlashInit.Data_Size = FLASH_mcu_size;
MCUFlashToExternalFlashInit.Sector_Address = 0; MCUFlashToExternalFlashInit.Sector_Address = FLASH_write;
MCUFlashToExternalFlashInit.Sector_Size = FLASH_mcu_size; MCUFlashToExternalFlashInit.Sector_Size = FLASH_mcu_size;
MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &MCUFlashToExternalFlashInit, 5000, 1); MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &MCUFlashToExternalFlashInit, 5000, 1);
MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, FLASH_read, read_buff, 15, 100); MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, FLASH_read, read_buff, 15, 100);
// Example for FLASH: erase/program/read functions // Example for FLASH (blocking): erase/program/read functions
// writting on two pages: // writting on two pages:
// writing 15 bytes at 0xf9 - its writting 7 bytes at first page, and 8 bytes at second page // writing 15 bytes at 0xf9 - its writting 7 bytes at first page, and 8 bytes at second page
MEMSPI_RES = MEMSPI_FLASH_Erase(&hmemspi, 0, 1, 1000, 1); MEMSPI_RES = MEMSPI_FLASH_Erase(&hmemspi, 0, 1, 1000, 1);
MEMSPI_RES = MEMSPI_FLASH_Program(&hmemspi, 0xf9, write_buff, 15, 100, 1); MEMSPI_RES = MEMSPI_FLASH_Program(&hmemspi, 0xf9, write_buff, 15, 100, 1);
MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0xf9, read_buff, 15, 100); MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0xf9, read_buff, 15, 100);
// Example for FLASH (blocking) (while(1)): write/read functions
#endif #endif
#ifdef EXT_EEPROM #ifdef EXT_EEPROM
// Example for EEPROM: writting MCU Program to external EEPROM // Example for EEPROM (blocking): writting MCU Program to external EEPROM
MEMSPI_RES = MEMSPI_EEPROM_Write(&hmemspi, 0, (uint8_t *)FLASH_BASE, FLASH_mcu_size, 2000, 0); MEMSPI_RES = MEMSPI_EEPROM_Write(&hmemspi, FLASH_write, (uint8_t *)FLASH_BASE, FLASH_mcu_size, 2000, 0);
MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, FLASH_read, read_buff, 15, 100); MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, FLASH_read, read_buff, 15, 100);
FLASH_read = 0x0; FLASH_read = 0x0;
#endif #endif
while (1) while (1)
{ {
FLASH_read = FLASH_write;
#ifdef EXT_FLASH #ifdef EXT_FLASH
// Example for FLASH: write/read functions // Example for FLASH (blocking): write/read functions
MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &writeInit, Timeout, 1); writeInit.fSavePrevoisData = 1;
MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0xf9, read_buff, 15, Timeout); writeInit.pDataPtr = write_buff;
writeInit.Data_Address = FLASH_write;
writeInit.Data_Size = 1;
writeInit.Sector_Address = FLASH_write;
writeInit.Sector_Size = 15;
// MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &writeInit, Timeout, 1);
// MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, FLASH_read, read_buff, 15, Timeout);
#endif #endif
#ifdef EXT_EEPROM #ifdef EXT_EEPROM
// Example for EEPROM: write/read functions // Example for EEPROM (blocking): write/read functions
MEMSPI_RES = MEMSPI_EEPROM_Write(&hmemspi, FLASH_write, write_buff, 15, Timeout, 1); MEMSPI_RES = MEMSPI_EEPROM_Write(&hmemspi, FLASH_write, write_buff, 15, Timeout, 1);
MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0+FLASH_read, read_buff, 15, Timeout); MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0+FLASH_read, read_buff, 15, Timeout);
#endif #endif

58
CubeKeil Example/MDK-ARM/flash eeprom Example.uvoptx
View File

@@ -152,9 +152,9 @@
<Bp> <Bp>
<Number>0</Number> <Number>0</Number>
<Type>0</Type> <Type>0</Type>
<LineNumber>156</LineNumber> <LineNumber>151</LineNumber>
<EnabledFlag>1</EnabledFlag> <EnabledFlag>1</EnabledFlag>
<Address>134230216</Address> <Address>134236100</Address>
<ByteObject>0</ByteObject> <ByteObject>0</ByteObject>
<HtxType>0</HtxType> <HtxType>0</HtxType>
<ManyObjects>0</ManyObjects> <ManyObjects>0</ManyObjects>
@@ -163,14 +163,14 @@
<BreakIfRCount>1</BreakIfRCount> <BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/main.c</Filename> <Filename>../Core/Src/main.c</Filename>
<ExecCommand></ExecCommand> <ExecCommand></ExecCommand>
<Expression>\\flash_eeprom_Example\../Core/Src/main.c\156</Expression> <Expression>\\flash_eeprom_Example\../Core/Src/main.c\151</Expression>
</Bp> </Bp>
<Bp> <Bp>
<Number>1</Number> <Number>1</Number>
<Type>0</Type> <Type>0</Type>
<LineNumber>160</LineNumber> <LineNumber>146</LineNumber>
<EnabledFlag>1</EnabledFlag> <EnabledFlag>1</EnabledFlag>
<Address>134230308</Address> <Address>134236064</Address>
<ByteObject>0</ByteObject> <ByteObject>0</ByteObject>
<HtxType>0</HtxType> <HtxType>0</HtxType>
<ManyObjects>0</ManyObjects> <ManyObjects>0</ManyObjects>
@@ -179,14 +179,14 @@
<BreakIfRCount>1</BreakIfRCount> <BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/main.c</Filename> <Filename>../Core/Src/main.c</Filename>
<ExecCommand></ExecCommand> <ExecCommand></ExecCommand>
<Expression>\\flash_eeprom_Example\../Core/Src/main.c\160</Expression> <Expression>\\flash_eeprom_Example\../Core/Src/main.c\146</Expression>
</Bp> </Bp>
<Bp> <Bp>
<Number>2</Number> <Number>2</Number>
<Type>0</Type> <Type>0</Type>
<LineNumber>169</LineNumber> <LineNumber>144</LineNumber>
<EnabledFlag>1</EnabledFlag> <EnabledFlag>1</EnabledFlag>
<Address>134230310</Address> <Address>134235990</Address>
<ByteObject>0</ByteObject> <ByteObject>0</ByteObject>
<HtxType>0</HtxType> <HtxType>0</HtxType>
<ManyObjects>0</ManyObjects> <ManyObjects>0</ManyObjects>
@@ -195,7 +195,7 @@
<BreakIfRCount>1</BreakIfRCount> <BreakIfRCount>1</BreakIfRCount>
<Filename>../Core/Src/main.c</Filename> <Filename>../Core/Src/main.c</Filename>
<ExecCommand></ExecCommand> <ExecCommand></ExecCommand>
<Expression>\\flash_eeprom_Example\../Core/Src/main.c\169</Expression> <Expression>\\flash_eeprom_Example\../Core/Src/main.c\144</Expression>
</Bp> </Bp>
</Breakpoint> </Breakpoint>
<WatchWindow1> <WatchWindow1>
@@ -212,7 +212,7 @@
<Ww> <Ww>
<count>2</count> <count>2</count>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<ItemText>MEMSPI_RES</ItemText> <ItemText>memspi_unique_ID</ItemText>
</Ww> </Ww>
<Ww> <Ww>
<count>3</count> <count>3</count>
@@ -286,12 +286,22 @@
<WinNumber>2</WinNumber> <WinNumber>2</WinNumber>
<ItemText>&amp;0x20000760</ItemText> <ItemText>&amp;0x20000760</ItemText>
</Ww> </Ww>
<Ww>
<count>6</count>
<WinNumber>2</WinNumber>
<ItemText>sector_buff</ItemText>
</Ww>
<Ww>
<count>7</count>
<WinNumber>2</WinNumber>
<ItemText>hspi</ItemText>
</Ww>
</WatchWindow2> </WatchWindow2>
<MemoryWindow1> <MemoryWindow1>
<Mm> <Mm>
<WinNumber>1</WinNumber> <WinNumber>1</WinNumber>
<SubType>0</SubType> <SubType>0</SubType>
<ItemText>0x08001532</ItemText> <ItemText>0x08000100</ItemText>
<AccSizeX>0</AccSizeX> <AccSizeX>0</AccSizeX>
</Mm> </Mm>
</MemoryWindow1> </MemoryWindow1>
@@ -299,7 +309,7 @@
<Mm> <Mm>
<WinNumber>2</WinNumber> <WinNumber>2</WinNumber>
<SubType>0</SubType> <SubType>0</SubType>
<ItemText>0x20000708</ItemText> <ItemText>0x20001778</ItemText>
<AccSizeX>0</AccSizeX> <AccSizeX>0</AccSizeX>
</Mm> </Mm>
</MemoryWindow2> </MemoryWindow2>
@@ -803,6 +813,30 @@
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
<bShared>0</bShared> <bShared>0</bShared>
</File> </File>
<File>
<GroupNumber>6</GroupNumber>
<FileNumber>33</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\GENERAL\spi_general.c</PathWithFileName>
<FilenameWithoutPath>spi_general.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>6</GroupNumber>
<FileNumber>34</FileNumber>
<FileType>5</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\..\GENERAL\spi_general.h</PathWithFileName>
<FilenameWithoutPath>spi_general.h</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group> </Group>
<Group> <Group>

10
CubeKeil Example/MDK-ARM/flash eeprom Example.uvprojx
View File

@@ -621,6 +621,16 @@
<FileType>5</FileType> <FileType>5</FileType>
<FilePath>..\..\GENERAL\periph_general.h</FilePath> <FilePath>..\..\GENERAL\periph_general.h</FilePath>
</File> </File>
<File>
<FileName>spi_general.c</FileName>
<FileType>1</FileType>
<FilePath>..\..\GENERAL\spi_general.c</FilePath>
</File>
<File>
<FileName>spi_general.h</FileName>
<FileType>5</FileType>
<FilePath>..\..\GENERAL\spi_general.h</FilePath>
</File>
</Files> </Files>
</Group> </Group>
<Group> <Group>

33
CubeKeil Example/flash eeprom Example.ioc
View File

@@ -11,7 +11,7 @@ Mcu.IP0=CRC
Mcu.IP1=NVIC Mcu.IP1=NVIC
Mcu.IP2=RCC Mcu.IP2=RCC
Mcu.IP3=RNG Mcu.IP3=RNG
Mcu.IP4=SPI1 Mcu.IP4=SPI2
Mcu.IP5=SYS Mcu.IP5=SYS
Mcu.IPNb=6 Mcu.IPNb=6
Mcu.Name=STM32F407V(E-G)Tx Mcu.Name=STM32F407V(E-G)Tx
@@ -20,9 +20,9 @@ Mcu.Pin0=PH0-OSC_IN
Mcu.Pin1=PH1-OSC_OUT Mcu.Pin1=PH1-OSC_OUT
Mcu.Pin10=VP_RNG_VS_RNG Mcu.Pin10=VP_RNG_VS_RNG
Mcu.Pin11=VP_SYS_VS_Systick Mcu.Pin11=VP_SYS_VS_Systick
Mcu.Pin2=PA5 Mcu.Pin2=PB13
Mcu.Pin3=PA6 Mcu.Pin3=PB14
Mcu.Pin4=PA7 Mcu.Pin4=PB15
Mcu.Pin5=PD12 Mcu.Pin5=PD12
Mcu.Pin6=PD13 Mcu.Pin6=PD13
Mcu.Pin7=PD14 Mcu.Pin7=PD14
@@ -45,12 +45,15 @@ NVIC.PriorityGroup=NVIC_PRIORITYGROUP_0
NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:true\:false\:false NVIC.SVCall_IRQn=true\:0\:0\:false\:false\:true\:true\:false\:false
NVIC.SysTick_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:false NVIC.SysTick_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:false
NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:true\:false\:false NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:true\:false\:false
PA5.Mode=Full_Duplex_Master PB13.Locked=true
PA5.Signal=SPI1_SCK PB13.Mode=Full_Duplex_Master
PA6.Mode=Full_Duplex_Master PB13.Signal=SPI2_SCK
PA6.Signal=SPI1_MISO PB14.Locked=true
PA7.Mode=Full_Duplex_Master PB14.Mode=Full_Duplex_Master
PA7.Signal=SPI1_MOSI PB14.Signal=SPI2_MISO
PB15.Locked=true
PB15.Mode=Full_Duplex_Master
PB15.Signal=SPI2_MOSI
PD12.Locked=true PD12.Locked=true
PD12.Signal=GPIO_Output PD12.Signal=GPIO_Output
PD13.Locked=true PD13.Locked=true
@@ -125,11 +128,11 @@ RCC.VCOI2SOutputFreq_Value=384000000
RCC.VCOInputFreq_Value=2000000 RCC.VCOInputFreq_Value=2000000
RCC.VCOOutputFreq_Value=128000000 RCC.VCOOutputFreq_Value=128000000
RCC.VcooutputI2S=192000000 RCC.VcooutputI2S=192000000
SPI1.CalculateBaudRate=4.0 MBits/s SPI2.CalculateBaudRate=4.0 MBits/s
SPI1.Direction=SPI_DIRECTION_2LINES SPI2.Direction=SPI_DIRECTION_2LINES
SPI1.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate SPI2.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate
SPI1.Mode=SPI_MODE_MASTER SPI2.Mode=SPI_MODE_MASTER
SPI1.VirtualType=VM_MASTER SPI2.VirtualType=VM_MASTER
VP_CRC_VS_CRC.Mode=CRC_Activate VP_CRC_VS_CRC.Mode=CRC_Activate
VP_CRC_VS_CRC.Signal=CRC_VS_CRC VP_CRC_VS_CRC.Signal=CRC_VS_CRC
VP_RNG_VS_RNG.Mode=RNG_Activate VP_RNG_VS_RNG.Mode=RNG_Activate

1
GENERAL/periph_general.h
View File

@@ -1,5 +1,6 @@
/********************************PERIPH************************************* /********************************PERIPH*************************************
Данный файл содержит инклюды и дефайны для всех библиотек базовой перефирии. Данный файл содержит инклюды и дефайны для всех библиотек базовой перефирии.
Для использования библиотеки для периферии нужно подключить этот файл.
***************************************************************************/ ***************************************************************************/
#ifndef __PERIPH_GENERAL_H_ #ifndef __PERIPH_GENERAL_H_
#define __PERIPH_GENERAL_H_ #define __PERIPH_GENERAL_H_

419
memory_spi/memory_spi.c
View File

@@ -34,8 +34,8 @@
#include "memory_spi.h" #include "memory_spi.h"
uint8_t sector_buff[MEMSPI_SECTOR_SIZE]; uint8_t sector_buff[MEMSPI_SECTOR_SIZE];
//------------------------------------------------------------- //-------------------------------------------------------------------
//--------------------------FOR USER--------------------------- //-----------------------------FOR USER------------------------------
/** /**
* @brief Initialize SPI and GPIO for MEMSPI FLASH. * @brief Initialize SPI and GPIO for MEMSPI FLASH.
* @param hmemspi - указатель на структуру с настройками SPI и GPIO портов. * @param hmemspi - указатель на структуру с настройками SPI и GPIO портов.
@@ -72,7 +72,29 @@ void MEMSPI_Base_Init(MEMSPI_HandleTypeDef *hmemspi)
HAL_GPIO_Init(hmemspi->CS_GPIOx, &GPIO_InitStruct); HAL_GPIO_Init(hmemspi->CS_GPIOx, &GPIO_InitStruct);
} }
//-----------------------INTERRUPT MODE FUNCTIONS--------------------
/**
* @brief Read external FLASH/EEPROM with interrupt.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс откуда начинать считывание.
* @param pBuff - куда записывать данные из FLASH.
* @param Size - сколько байтов считывать.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return HAL status.
*/
HAL_StatusTypeDef MEMSPI_Read_Memory_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size)
{
HAL_StatusTypeDef MEMSPI_Status;
uint32_t tickstart = HAL_GetTick();
MEMSPI_Status = MEMSPI_CMD_Read_Data_IT(hmemspi, FLASH_Address, pBuff, Size);
if(MEMSPI_Status != HAL_OK)
return MEMSPI_Status;
return HAL_OK;
}
//-----------------------BLOCKING MODE FUNCTIONS---------------------
/** /**
* @brief Read external FLASH/EEPROM. * @brief Read external FLASH/EEPROM.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -190,7 +212,6 @@ HAL_StatusTypeDef MEMSPI_FLASH_Write(MEMSPI_HandleTypeDef *hmemspi, MEMSPI_Write
// WRITE FLASH WITH SAVING PREVIOUS DATA // WRITE FLASH WITH SAVING PREVIOUS DATA
if(WriteInit->fSavePrevoisData) if(WriteInit->fSavePrevoisData)
{ {
// uint8_t sector_buff[WriteInit->Sector_Size];
// store data from flash // store data from flash
MEMSPI_Status = MEMSPI_Read_Memory(hmemspi, WriteInit->Sector_Address, sector_buff, WriteInit->Sector_Size, Timeout); MEMSPI_Status = MEMSPI_Read_Memory(hmemspi, WriteInit->Sector_Address, sector_buff, WriteInit->Sector_Size, Timeout);
if(MEMSPI_Status != HAL_OK) if(MEMSPI_Status != HAL_OK)
@@ -346,8 +367,90 @@ HAL_StatusTypeDef MEMSPI_FLASH_Erase(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLA
} }
//------------------------------------------------------------- //-------------------------------------------------------------------
//----------------------SERVICE FUNCTIONS---------------------- //-------------------------SERVICE FUNCTIONS-------------------------
//----------------------INTERRUPT MODE FUNCTIONS---------------------
/**
* @brief Handler for SPI FLASH/EEPROM.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note Включает в себя проверку на доступность памяти (флаг BUSY)
*/
void MEMSPI_Handler(MEMSPI_HandleTypeDef *hmemspi)
{
HAL_SPI_StateTypeDef active_line = hmemspi->sspi.hspi.State;
HAL_SPI_IRQHandler(&hmemspi->sspi.hspi);
/* RX Callback */
if (( hmemspi->sspi.hspi.RxXferCount == 0U) && (hmemspi->MEM_State == MEM_RECEIVE_DATA) && // if all bytes are received and receive is active
hmemspi->sspi.hspi.State != HAL_SPI_STATE_BUSY_RX) // also check that receive "REALLY" isnt busy
MEM_SPI_OperationCplt_Handler(hmemspi);
/* TX Callback */
if (( hmemspi->sspi.hspi.TxXferCount == 0U) && (hmemspi->MEM_State == MEM_SEND_COMMAND) && // if all bytes are transmited and transmit is active
hmemspi->sspi.hspi.State != HAL_SPI_STATE_BUSY_TX) // also check that transmit "REALLY" isnt busy
MEM_SPI_TransmitCommandCplt_Handler(hmemspi);
}
/**
* @brief Handler for transmit SPI command to EEPROM/FLASH.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note После отправки комманды - инициализирует прием ответа если надо или завершает команду.
*/
void MEM_SPI_TransmitCommandCplt_Handler(MEMSPI_HandleTypeDef *hmemspi)
{
__HAL_UNLOCK(&hmemspi->sspi.hspi);
uint8_t endcmd = 0;
hmemspi->MEM_State = MEM_RECEIVE_DATA;
switch(hmemspi->Active_CMD)
{
case WRITE_ENABLE: endcmd = 1; break;
case WRITE_DISABLE: endcmd = 1; break;
case WRITE_STATUS_REG: endcmd = 1; break;
case ERASE_SECTOR: endcmd = 1; break;
case PAGE_PROGRAM: endcmd = 1; break;
case READ_STATUS_REG: MEMSPI_SPI_Receive_IT(hmemspi, (uint8_t *)&hmemspi->SR, 1); break;
case READ_DATA: MEMSPI_SPI_Receive_IT(hmemspi, hmemspi->pRxBuffPtr, hmemspi->RxXferSize); break;
case READ_JEDEC_ID: MEMSPI_SPI_Receive_IT(hmemspi, &hmemspi->pRxBuffPtr[1], 3); break;
case READ_UNIQUE_ID: MEMSPI_SPI_Receive_IT(hmemspi, hmemspi->pRxBuffPtr, 8); break;
default: break;
}
}
/**
* @brief Handler for receive SPI response from EEPROM/FLASH.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note Завершает общение с памятью.
*/
void MEM_SPI_OperationCplt_Handler(MEMSPI_HandleTypeDef *hmemspi)
{
__HAL_UNLOCK(&hmemspi->sspi.hspi);
uint64_t return_val_LO;
uint64_t return_val_HI;
switch(hmemspi->Active_CMD)
{
case READ_JEDEC_ID:
*(uint32_t *)hmemspi->pRxBuffPtr = __REV((*(uint64_t *)hmemspi->pRxBuffPtr)) & 0xFFFFFF;
break;
case READ_UNIQUE_ID:
return_val_LO = (*(uint64_t *)hmemspi->pRxBuffPtr) >> 32;
return_val_HI = (*(uint64_t *)hmemspi->pRxBuffPtr) & 0xFFFFFFFF;
*(uint64_t *)hmemspi->pRxBuffPtr = ((uint64_t)__REV(return_val_HI) << 32) | __REV(return_val_LO);
break;
default: break;
}
hmemspi->Active_CMD = WAIT_FOR_CMD;
MEMSPI_Deselect(hmemspi);
}
//-----------------------BLOCKING MODE FUNCTIONS--------------------
/** /**
* @brief Write page in external EEPROM. * @brief Write page in external EEPROM.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -508,6 +611,54 @@ HAL_StatusTypeDef MEMSPI_WriteEnablingUntilTimeout(MEMSPI_HandleTypeDef *hmemspi
* @note Считывает флаги до тех пор, пока они не будут в состоянии FlagStatus или до тех пор, пока таймаут не истечет. * @note Считывает флаги до тех пор, пока они не будут в состоянии FlagStatus или до тех пор, пока таймаут не истечет.
*/ */
HAL_StatusTypeDef MEMSPI_WaitOnFlagsUntilTimeout(MEMSPI_HandleTypeDef *hmemspi, uint16_t FlagMask, uint16_t FlagStatus, uint32_t *Timeout, uint32_t *tickstart) HAL_StatusTypeDef MEMSPI_WaitOnFlagsUntilTimeout(MEMSPI_HandleTypeDef *hmemspi, uint16_t FlagMask, uint16_t FlagStatus, uint32_t *Timeout, uint32_t *tickstart)
{
HAL_StatusTypeDef MEMSPI_Status;
uint32_t tickstart_reserve;
uint32_t max_delay = HAL_MAX_DELAY;
if(tickstart == NULL)
tickstart = &tickstart_reserve;
if(Timeout == NULL)
Timeout = &max_delay;
// check flags
do{
if(hmemspi->sspi.hspi.State == HAL_SPI_STATE_READY)
MEMSPI_Status = MEMSPI_CMD_Read_Status_Register(hmemspi, FlagMask, 0, *Timeout);
}while(((HAL_GetTick() - *tickstart) < *Timeout) && (MEMSPI_Status != HAL_OK));
while((hmemspi->SR&FlagMask) != FlagStatus)
{
// check flags
// MEMSPI_Status = MEMSPI_CMD_Read_Status_Register(hmemspi, FlagMask, *Timeout);
MEMSPI_Status = MEMSPI_SPI_Receive(hmemspi, (uint8_t *)&hmemspi->SR, 1, *Timeout); // receive response
if(MEMSPI_Status != HAL_OK)
{
MEMSPI_Deselect(hmemspi);
return MEMSPI_Status;
}
if((HAL_GetTick() - *tickstart) >= *Timeout) // if time is out
{
MEMSPI_Deselect(hmemspi);
return HAL_TIMEOUT; // set timeout
}
}
MEMSPI_Deselect(hmemspi);
MEMSPI_Update_Timeout_Variables(Timeout, tickstart);
return HAL_OK; // if all ok return HAL_OK
}
/**
* @brief Wait for flag until timeout in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FlagMask - маска для флагов, какие флаги считывать.
* @param FlagStatus - какое состояние должно быть у выбранных флагов.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @param tickstart - время, относительно которого надо отсчитывать таймаут.
* @return HAL status.
* @note Считывает флаги до тех пор, пока они не будут в состоянии FlagStatus или до тех пор, пока таймаут не истечет.
*/
HAL_StatusTypeDef MEMSPI_WaitOnFlagsUntilTimeout_IT(MEMSPI_HandleTypeDef *hmemspi, uint16_t FlagMask, uint16_t FlagStatus, uint32_t *Timeout, uint32_t *tickstart)
{ {
HAL_StatusTypeDef MEMSPI_Status; HAL_StatusTypeDef MEMSPI_Status;
// check flags // check flags
@@ -547,8 +698,9 @@ void MEMSPI_Update_Timeout_Variables(uint32_t *Timeout, uint32_t *tickstart)
*Timeout -= timeoutcnt; *Timeout -= timeoutcnt;
*tickstart += timeoutcnt; *tickstart += timeoutcnt;
} }
//------------------------------------------------------------- //-------------------------------------------------------------------
//----------------------COMMAND FUNCTIONS---------------------- //-------------------------COMMAND FUNCTIONS-------------------------
//------------------------------BLOCKING-----------------------------
/** /**
* @brief Send command to read Status Register. * @brief Send command to read Status Register.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -618,10 +770,8 @@ HAL_StatusTypeDef MEMSPI_CMD_Write_Status_Register(MEMSPI_HandleTypeDef *hmemspi
command[1] = WrittenBits; command[1] = WrittenBits;
command[2] = WrittenBits >> 8; command[2] = WrittenBits >> 8;
size = 3;
MEMSPI_Select(hmemspi); MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit(hmemspi, command, size, Timeout); SPI_RES = MEMSPI_SPI_Transmit(hmemspi, command, 3, Timeout);
MEMSPI_Deselect(hmemspi); MEMSPI_Deselect(hmemspi);
return SPI_RES; return SPI_RES;
@@ -645,7 +795,6 @@ HAL_StatusTypeDef MEMSPI_CMD_Write_Enable(MEMSPI_HandleTypeDef *hmemspi, uint32_
return SPI_RES; return SPI_RES;
} }
/** /**
* @brief Send command to read data from FLASH/EEPROM. * @brief Send command to read data from FLASH/EEPROM.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -659,7 +808,6 @@ HAL_StatusTypeDef MEMSPI_CMD_Read_Data(MEMSPI_HandleTypeDef *hmemspi, uint32_t F
{ {
HAL_StatusTypeDef SPI_RES; HAL_StatusTypeDef SPI_RES;
uint8_t command[4]; uint8_t command[4];
uint8_t response[2] = {0};
command[0] = MEMSPI_READ_DATA; command[0] = MEMSPI_READ_DATA;
command[1] = FLASH_Address >> 16 & 0xFF; command[1] = FLASH_Address >> 16 & 0xFF;
@@ -837,5 +985,250 @@ HAL_StatusTypeDef MEMSPI_CMD_Fast_Read(MEMSPI_HandleTypeDef *hmemspi, uint32_t F
return SPI_RES; return SPI_RES;
} }
//-------------------------------------------------------------
//-------------------------------------------------------------------
//-------------------------COMMAND FUNCTIONS-------------------------
//-----------------------------INTERRUPT-----------------------------
/**
* @brief Send command to read Status Register.
* @param hmemspi - указатель на хендл внешней памяти.
* @param RequestedBits - какие биты запросить.
* @param EndCMD - завершать комманду или нет. (очистка Chip Selected пина)
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return Заполняет Status Register в hmemspi.
* @note Всего есть две комманды: на запрос верхнего или нижниго байта.
* Функция в соответствии с RequestedBits определяет какой байт запросить, или два байта сразу.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Status_Register_IT(MEMSPI_HandleTypeDef *hmemspi, uint16_t RequestedBits, uint8_t EndCMD)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[2];
uint8_t *pSRPtr = 0;
uint8_t size = 1;
command[0] = MEMSPI_READ_STATUS_REG;
hmemspi->Active_OP = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 1); // send insctruction to read SR
return SPI_RES;
}
/**
* @brief Send command to write bits in Status Register.
* @param hmemspi - указатель на хендл внешней памяти.
* @param WrittenBits - какие биты запросить.
* @note Данная команда посылает биты, как сдвинутые на 2 вправо. Т.е. 0-й бит в комманде - 2-й бит BP0.
Но биты указываются в также как они расположены и регистре. Функция сама выполняет сдвиг.
*/
HAL_StatusTypeDef MEMSPI_CMD_Write_Status_Register_IT(MEMSPI_HandleTypeDef *hmemspi, uint16_t WrittenBits)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[3];
uint8_t size;
command[0] = MEMSPI_WRITE_STATUS_REG;
command[1] = WrittenBits;
command[2] = WrittenBits >> 8;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 3);
return SPI_RES;
}
/**
* @brief Send command to set Write Enable Latch (WEL) in Status Register.
* @param hmemspi - указатель на хендл внешней памяти.
* @note Разрешает запись в FLASH, путем высталения WEL в Status Register
*/
HAL_StatusTypeDef MEMSPI_CMD_Write_Enable_IT(MEMSPI_HandleTypeDef *hmemspi)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[1];
command[0] = MEMSPI_WRITE_ENABLE;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 1);
return SPI_RES;
}
/**
* @brief Send command to read data from FLASH/EEPROM.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс откуда начинать считывание.
* @param pBuff - куда записывать данные из FLASH.
* @param Size - сколько байтов считывать.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return pBuff.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Data_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[4];
command[0] = MEMSPI_READ_DATA;
command[1] = FLASH_Address >> 16 & 0xFF;
command[2] = FLASH_Address >> 8 & 0xFF;
command[3] = FLASH_Address & 0xFF;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
hmemspi->pRxBuffPtr = pBuff;
hmemspi->RxXferSize = Size;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 4);
return SPI_RES;
}
/**
* @brief Send command to write eeprom.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс куда начинать записывать.
* @param pData - откуда брать данные для записи в FLASH.
* @param Size - сколько байтов записать.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Рзамер данных для записи в EEPROM без ограничений.
*/
HAL_StatusTypeDef MEMSPI_CMD_EEPROM_Write_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pData, uint16_t Size)
{
HAL_StatusTypeDef SPI_RES;
// 1 command byte + 3 address bytes + 256 data bytes
uint8_t command[1+3+MEMSPI_PAGE_SIZE];
FLASH_Address = FLASH_Address & 0xFFFFFF;
command[0] = MEMSPI_WRITE_EEPROM;
command[1] = FLASH_Address >> 16 & 0xFF;
command[2] = FLASH_Address >> 8 & 0xFF;
command[3] = FLASH_Address & 0xFF;
// check if data range is placed at one page
if((FLASH_Address/MEMSPI_PAGE_SIZE) != ((FLASH_Address+Size-1)/MEMSPI_PAGE_SIZE)) // if page of first byte isnt equal page of last byte
return HAL_ERROR; // return error
for(int i = 0; i < Size; i++)
command[4+i] = pData[i];
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, Size+4); // send insctruction+data to write
return SPI_RES;
}
/**
* @brief Send command to page program in FLASH.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс куда начинать записывать.
* @param pData - откуда брать данные для записи в FLASH.
* @param Size - сколько байтов записать.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Программирование FLASH только в пределах одной страницы.
* Т.е. если запись с 0x0, то не больше 256 байт. Если с 0ч40, то не больше 192 байт.
*/
HAL_StatusTypeDef MEMSPI_CMD_FLASH_Page_Program_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pData, uint16_t Size)
{
HAL_StatusTypeDef SPI_RES;
// 1 command byte + 3 address bytes + 256 data bytes
uint8_t command[1+3+MEMSPI_PAGE_SIZE];
FLASH_Address = FLASH_Address & 0xFFFFFF;
command[0] = MEMSPI_PAGE_PROGRAM;
command[1] = FLASH_Address >> 16 & 0xFF;
command[2] = FLASH_Address >> 8 & 0xFF;
command[3] = FLASH_Address & 0xFF;
// check if data range is placed at one page
if((FLASH_Address/MEMSPI_PAGE_SIZE) != ((FLASH_Address+Size-1)/MEMSPI_PAGE_SIZE)) // if page of first byte isnt equal page of last byte
return HAL_ERROR; // return error
for(int i = 0; i < Size; i++)
command[4+i] = pData[i];
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, Size+4); // send insctruction+data to write
return SPI_RES;
}
/**
* @brief Send command to erase sector.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс где надо данные стереть.
* @param Timeout - время, за которое должна быть осуществлена очистка.
* @note Микросхема вроде сама высчитывает какой сектор ерейзнуть, в соответствии с заданным адресом.
*/
HAL_StatusTypeDef MEMSPI_CMD_FLASH_Erase_Sector_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[4];
uint8_t response[8];
FLASH_Address = FLASH_Address & 0xFFFFFF;
command[0] = MEMSPI_ERASE_SECTOR;
command[1] = FLASH_Address >> 16;
command[2] = FLASH_Address >> 8;
command[3] = FLASH_Address;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 4);
return SPI_RES;
}
/**
* @brief Send command to read JEDEC ID.
* @param hmemspi - указатель на хендл внешней памяти.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return JEDEC ID микросхемы.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_JEDEC_ID_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t *JEDEC_ID_var)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[1] = {0};
command[0] = MEMSPI_READ_JEDEC_ID;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
hmemspi->pRxBuffPtr = (uint8_t *)&JEDEC_ID_var[0];
hmemspi->RxXferSize = 4;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 1);
return SPI_RES;
}
/**
* @brief Send command to read JEDEC ID.
* @param hmemspi - указатель на хендл внешней памяти.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return Device ID микросхемы.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Device_ID_IT(MEMSPI_HandleTypeDef *hmemspi, uint64_t *Device_ID_var)
{
HAL_StatusTypeDef SPI_RES;
uint8_t command[1] = {0};
uint8_t receive[8] = {0};
command[0] = MEMSPI_READ_UNIQUE_ID;
hmemspi->Active_CMD = command[0];
hmemspi->MEM_State = MEM_SEND_COMMAND;
hmemspi->pRxBuffPtr = (uint8_t *)&Device_ID_var[0];
hmemspi->RxXferSize = 8;
MEMSPI_Select(hmemspi);
SPI_RES = MEMSPI_SPI_Transmit_IT(hmemspi, command, 1);
return SPI_RES;
}

220
memory_spi/memory_spi.h
View File

@@ -22,20 +22,22 @@
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
////////////////////////////---DEFINES---//////////////////////////// ////////////////////////////---DEFINES---////////////////////////////
/** /**
* @brief SPI Transmit. * @brief SPI Transmit IT.
* @param _hmemspi_ - указатель на хендл внешней памяти.
* @param _data_ - указатель на данные для отправки.
* @param _size_ - размер данных для отправки.
* @param _timeout_ - время, за которое должна быть осуществлена отправка.
* @note Здесь вызывается только функция HAL, и ничего больше. * @note Здесь вызывается только функция HAL, и ничего больше.
*/ */
#define MEMSPI_SPI_Transmit(_hmemspi_, _data_, _size_, _timeout_) HAL_SPI_Transmit(&_hmemspi_->sspi.hspi, _data_, _size_, _timeout_) #define MEMSPI_SPI_Transmit_IT(_hmemspi_, _data_, _size_) HAL_SPI_Transmit_IT(&_hmemspi_->sspi.hspi, _data_, _size_)
/**
* @brief SPI Receive IT.
* @note Здесь вызывается только функция HAL, и ничего больше.
*/
#define MEMSPI_SPI_Receive_IT(_hmemspi_, _data_, _size_) HAL_SPI_Receive_IT(&_hmemspi_->sspi.hspi, _data_, _size_)
/**
* @brief SPI Transmit.
* @note Здесь вызывается только функция HAL, и ничего больше.
*/
#define MEMSPI_SPI_Transmit(_hmemspi_, _data_, _size_, _timeout_) HAL_SPI_Transmit(&_hmemspi_->sspi.hspi, _data_, _size_, _timeout_)
/** /**
* @brief SPI Receive. * @brief SPI Receive.
* @param _hmemspi_ - указатель на хендл внешней памяти.
* @param _data_ - указатель на буффер для прниема данных.
* @param _size_ - размер данных для приема.
* @param _timeout_ - время, за которое должен быть осуществлен прием.
* @note Здесь вызывается только функция HAL, и ничего больше. * @note Здесь вызывается только функция HAL, и ничего больше.
*/ */
#define MEMSPI_SPI_Receive(_hmemspi_, _data_, _size_, _timeout_) HAL_SPI_Receive(&_hmemspi_->sspi.hspi, _data_, _size_, _timeout_) #define MEMSPI_SPI_Receive(_hmemspi_, _data_, _size_, _timeout_) HAL_SPI_Receive(&_hmemspi_->sspi.hspi, _data_, _size_, _timeout_)
@@ -111,30 +113,58 @@ typedef struct
unsigned fSavePrevoisData:1; unsigned fSavePrevoisData:1;
}MEMSPI_WriteInitTypeDef; }MEMSPI_WriteInitTypeDef;
typedef struct typedef enum
{ {
uint16_t SR; WAIT_FOR_CMD = 0x00,
SPI_HandleTypeDef hspi; WRITE_ENABLE = MEMSPI_WRITE_ENABLE,
GPIO_TypeDef *CS_GPIOx; WRITE_DISABLE = MEMSPI_WRITE_DISABLE,
uint32_t CS_PIN; WRITE_STATUS_REG = MEMSPI_WRITE_STATUS_REG,
GPIO_TypeDef *CLK_GPIOx;
uint32_t CLK_PIN; READ_DATA = MEMSPI_READ_DATA,
GPIO_TypeDef *MISO_GPIOx;
uint32_t MISO_PIN; ERASE_SECTOR = MEMSPI_ERASE_SECTOR,
GPIO_TypeDef *MOSI_GPIOx; PAGE_PROGRAM = MEMSPI_PAGE_PROGRAM,
uint32_t MOSI_PIN; WRITE_EEPROM = MEMSPI_WRITE_EEPROM,
}MEMSPI_GPIOTypeDef; READ_STATUS_REG = MEMSPI_READ_STATUS_REG,
READ_JEDEC_ID = MEMSPI_READ_JEDEC_ID,
READ_UNIQUE_ID = MEMSPI_READ_UNIQUE_ID,
}MEMSPI_CommandsTypeDef;
typedef enum
{
WAIT_FOR_UNBUSY,
READ_MEMORY,
EEPROM_WRITE,
FLASH_PROGRAM,
FLASH_ERASE,
}MEM_OperationsTypeDef;
typedef enum
{
MEM_READY = 0x00,
MEM_SEND_COMMAND = 0x01,
MEM_RECEIVE_DATA = 0x02,
}MEM_StateTypeDef;
typedef struct typedef struct
{ {
uint16_t SR; uint16_t SR;
SPI_SettingsTypeDef sspi;
// MEMSPI_GPIOTypeDef GPIOs; SPI_SettingsTypeDef sspi;
GPIO_TypeDef *CS_GPIOx; GPIO_TypeDef *CS_GPIOx;
uint32_t CS_PIN; uint32_t CS_PIN;
uint32_t hNextAddr;
uint16_t hNextPage; MEM_OperationsTypeDef Active_OP;
uint16_t hNextSector; MEMSPI_CommandsTypeDef Active_CMD;
MEM_StateTypeDef MEM_State;
uint8_t *pRxBuffPtr;
uint16_t RxXferSize;
uint32_t hNextAddr;
uint16_t hNextPage;
uint16_t hNextSector;
}MEMSPI_HandleTypeDef; }MEMSPI_HandleTypeDef;
extern MEMSPI_HandleTypeDef hmemspi; extern MEMSPI_HandleTypeDef hmemspi;
@@ -148,6 +178,17 @@ extern MEMSPI_HandleTypeDef hmemspi;
*/ */
void MEMSPI_Base_Init(MEMSPI_HandleTypeDef *hmemspi); void MEMSPI_Base_Init(MEMSPI_HandleTypeDef *hmemspi);
/**
* @brief Read external FLASH/EEPROM with interrupt.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс откуда начинать считывание.
* @param pBuff - куда записывать данные из FLASH.
* @param Size - сколько байтов считывать.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return HAL status.
*/
HAL_StatusTypeDef MEMSPI_Read_Memory_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size);
/** /**
* @brief Read external FLASH. * @brief Read external FLASH.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -285,8 +326,36 @@ HAL_StatusTypeDef MEMSPI_WaitOnFlagsUntilTimeout(MEMSPI_HandleTypeDef *hmemspi,
void MEMSPI_Update_Timeout_Variables(uint32_t *Timeout, uint32_t *tickstart); void MEMSPI_Update_Timeout_Variables(uint32_t *Timeout, uint32_t *tickstart);
////////////////////////---SERVICE FUNCTIONS---////////////////////// ////////////////////////---SERVICE FUNCTIONS---//////////////////////
/////////////////////////////////////////////////////////////////////
///////////////////////---HANDLERS FUNCTIONS---//////////////////////
/**
* @brief Handler for SPI FLASH/EEPROM.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note Включает в себя проверку на доступность памяти (флаг BUSY)
*/
void MEMSPI_Handler(MEMSPI_HandleTypeDef *hmemspi);
/**
* @brief Handler for transmit SPI command to EEPROM/FLASH.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note После отправки комманды - инициализирует прием ответа если надо или завершает команду.
*/
void MEM_SPI_TransmitCommandCplt_Handler(MEMSPI_HandleTypeDef *hmemspi);
/**
* @brief Handler for receive SPI response from EEPROM/FLASH.
* @param hmemspi - указатель на хендл внешней памяти.
* @return HAL status.
* @note Завершает общение с памятью.
*/
void MEM_SPI_OperationCplt_Handler(MEMSPI_HandleTypeDef *hmemspi);
///////////////////////---HANDLERS FUNCTIONS---//////////////////////
///////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////
//////////////////////---FUNCTION FOR COMMAND---///////////////////// //////////////////////---FUNCTION FOR COMMAND---/////////////////////
////////////////////////////---BLOCKING---///////////////////////////
/** /**
* @brief Send command to read Status Register. * @brief Send command to read Status Register.
* @param hmemspi - указатель на хендл внешней памяти. * @param hmemspi - указатель на хендл внешней памяти.
@@ -383,7 +452,100 @@ uint64_t MEMSPI_CMD_Read_Device_ID(MEMSPI_HandleTypeDef *hmemspi, uint32_t Timeo
* @note Данная функция предполагает отправку одного dummy байта после адресса, но у меня поч не работает пока :( * @note Данная функция предполагает отправку одного dummy байта после адресса, но у меня поч не работает пока :(
*/ */
HAL_StatusTypeDef MEMSPI_CMD_Fast_Read(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size, uint32_t Timeout); HAL_StatusTypeDef MEMSPI_CMD_Fast_Read(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size, uint32_t Timeout);
////////////////////////////---BLOCKING---///////////////////////////
//////////////////////---FUNCTION FOR COMMAND---///////////////////// //////////////////////---FUNCTION FOR COMMAND---/////////////////////
/////////////////////////////////////////////////////////////////////
//////////////////////---FUNCTION FOR COMMAND---/////////////////////
///////////////////////////---INTERRUPT---///////////////////////////
/**
* @brief Send command to read Status Register in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param RequestedBits - какие биты запросить.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return Заполняет Status Register в hmemspi.
* @note Всего есть две комманды: на запрос верхнего или нижниго байта.
* Функция в соответствии с RequestedBits определяет какой байт запросить, или два байта сразу.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Status_Register_IT(MEMSPI_HandleTypeDef *hmemspi, uint16_t RequestedBits, uint8_t EndCMD);
/**
* @brief Send command to write bits in Status Register in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param WrittenBits - какие биты запросить.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Данная команда посылает биты, как сдвинутые на 2 вправо. Т.е. 0-й бит в комманде - 2-й бит BP0.
Но биты указываются в также как они расположены и регистре. Функция сама выполняет сдвиг.
*/
HAL_StatusTypeDef MEMSPI_CMD_Write_Status_Register_IT(MEMSPI_HandleTypeDef *hmemspi, uint16_t WrittenBits);
/**
* @brief Send command to set Write Enable Latch (WEL) in Status Register in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Разрешает запись в FLASH, путем высталения WEL в Status Register
*/
HAL_StatusTypeDef MEMSPI_CMD_Write_Enable_IT(MEMSPI_HandleTypeDef *hmemspi);
/**
* @brief Send command to read data from FLASH/EEPROM in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс откуда начинать считывание.
* @param pBuff - куда записывать данные из FLASH.
* @param Size - сколько байтов считывать.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return pBuff.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Data_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pBuff, uint16_t Size);
/**
* @brief Send command to write eeprom in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс куда начинать записывать.
* @param pData - откуда брать данные для записи в FLASH.
* @param Size - сколько байтов записать.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Рзамер данных для записи в EEPROM без ограничений.
*/
HAL_StatusTypeDef MEMSPI_CMD_EEPROM_Write_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pData, uint16_t Size);
/**
* @brief Send command to page program in FLASH in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс куда начинать записывать.
* @param pData - откуда брать данные для записи в FLASH.
* @param Size - сколько байтов записать.
* @param Timeout - время, за которое должна быть осуществлена запись.
* @note Программирование FLASH только в пределах одной страницы.
* Т.е. если запись с 0x0, то не больше 256 байт. Если с 0ч40, то не больше 192 байт.
*/
HAL_StatusTypeDef MEMSPI_CMD_FLASH_Page_Program_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address, uint8_t *pData, uint16_t Size);
/**
* @brief Send command to erase sector of FLASH in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param FLASH_Address - адресс где надо данные стереть.
* @param Timeout - время, за которое должна быть осуществлена очистка.
* @note Микросхема вроде сама высчитывает какой сектор ерейзнуть, в соответствии с заданным адресом.
*/
HAL_StatusTypeDef MEMSPI_CMD_FLASH_Erase_Sector_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t FLASH_Address);
/**
* @brief Send command to read JEDEC ID in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return JEDEC ID микросхемы.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_JEDEC_ID_IT(MEMSPI_HandleTypeDef *hmemspi, uint32_t *JEDEC_ID_var);
/**
* @brief Send command to read JEDEC ID in interrupt mode.
* @param hmemspi - указатель на хендл внешней памяти.
* @param Timeout - время, за которое должно быть осуществлено чтение.
* @return Device ID микросхемы.
*/
HAL_StatusTypeDef MEMSPI_CMD_Read_Device_ID_IT(MEMSPI_HandleTypeDef *hmemspi, uint64_t *Device_ID_var);
///////////////////////////---INTERRUPT---///////////////////////////
//////////////////////---FUNCTION FOR COMMAND---/////////////////////
#endif // __SPI_MEMORY_H_ #endif // __SPI_MEMORY_H_