Добавлены проверки на режим прерывания (пока ниче не работает)

Начало работы над прерываниями
2024-08-14 18:28:35 +03:00 · 2024-08-14 18:27:50 +03:00
7 changed files with 733 additions and 104 deletions
--- a/Example/Core/Src/main.c
+++ b/Example/Core/Src/main.c
@@ -65,14 +65,20 @@ MEMSPI_WriteInitTypeDef MCUFlashToExternalFlashInit;
 uint8_t read_buff[20] = {0};
 // what writting in examples in while(1)
 uint8_t write_buff[20] = {0x14,0x13,0x12,0x11,0x10,
-                        0x0F,0x0E,0x0D,0x0C,0x0B,
-                        0x0A,0x09,0x08,0x07,0x06,
-                        0x05,0x04,0x03,0x02,0x01};
+0x0F,0x0E,0x0D,0x0C,0x0B,
+0x0A,0x09,0x08,0x07,0x06,
+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_read = 0x100;			// where read
+uint32_t FLASH_read = 0x1100;			// where read
 uint32_t Timeout = 1000;					// timeout for examples in while(1)
+
+void SPI2_IRQHandler(void)
+{
+	MEMSPI_Handler(&hmemspi);
+}
+												
 /* USER CODE END 0 */

 /**
@@ -107,16 +113,16 @@ int main(void)
  MX_RNG_Init();
  /* USER CODE BEGIN 2 */
 	// FLASH MEMSPI INIT
-	hmemspi.hspi.Instance = SPI2;	
-	hmemspi.hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;	
-	hmemspi.GPIOs.CS_GPIOx = GPIOA;
-	hmemspi.GPIOs.CS_PIN = 	GPIO_PIN_4;
-	hmemspi.GPIOs.CLK_GPIOx = GPIOB;
-	hmemspi.GPIOs.CLK_PIN = 	GPIO_PIN_13;
-	hmemspi.GPIOs.MISO_GPIOx = GPIOC;
-	hmemspi.GPIOs.MISO_PIN = GPIO_PIN_2;
-	hmemspi.GPIOs.MOSI_GPIOx = GPIOC;	
-	hmemspi.GPIOs.MOSI_PIN = GPIO_PIN_3;
+	hmemspi.sspi.hspi.Instance = SPI2;	
+	hmemspi.sspi.hspi.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_128;	
+	hmemspi.CS_GPIOx = GPIOA;
+	hmemspi.CS_PIN = 	GPIO_PIN_4;
+	hmemspi.sspi.CLK_GPIOx = GPIOB;
+	hmemspi.sspi.CLK_PIN = GPIO_PIN_13;
+	hmemspi.sspi.MISO_GPIOx = GPIOB;
+	hmemspi.sspi.MISO_PIN = GPIO_PIN_14;
+	hmemspi.sspi.MOSI_GPIOx = GPIOB;	
+	hmemspi.sspi.MOSI_PIN = GPIO_PIN_15;
 	MEMSPI_Base_Init(&hmemspi);
 	
  /* USER CODE END 2 */
@@ -124,48 +130,68 @@ int main(void)
  /* Infinite loop */
  /* USER CODE BEGIN WHILE */	
 	
-	// Example for FLASH: using manufactire info CMD
-	uint32_t memspi_ID = MEMSPI_CMD_Read_JEDEC_ID(&hmemspi, 100);
-	uint64_t memspi_unique_ID = MEMSPI_CMD_Read_Device_ID(&hmemspi, 100);
-#ifdef EXT_FLASH
-	// Example fpr FLASH: writting MCU Program to external FLASH
-	writeInit.fSavePrevoisData = 1;
-	writeInit.pDataPtr = write_buff;
-	writeInit.Data_Address = 0xfb;
-	writeInit.Data_Size = 1;
-	writeInit.Sector_Address = 0xf9;
-	writeInit.Sector_Size = 15;
+	// Example for FLASH (interrupt): using manufactire info CMD
+	uint32_t memspi_ID;
+	uint64_t memspi_unique_ID;
+	MEMSPI_CMD_Read_JEDEC_ID_IT(&hmemspi, &memspi_ID);
+	HAL_Delay(100);
+	MEMSPI_CMD_Read_Device_ID_IT(&hmemspi, &memspi_unique_ID);
+	HAL_Delay(100);
 	
+	// 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.Data_Address = 0;
+	MCUFlashToExternalFlashInit.Data_Address = FLASH_write;
 	MCUFlashToExternalFlashInit.Data_Size = FLASH_mcu_size;
-	MCUFlashToExternalFlashInit.Sector_Address = 0;
+	MCUFlashToExternalFlashInit.Sector_Address = FLASH_write;
 	MCUFlashToExternalFlashInit.Sector_Size = FLASH_mcu_size;
 	MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &MCUFlashToExternalFlashInit, 5000, 1);
 	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:
 	// 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_Program(&hmemspi, 0xf9, write_buff, 15, 100, 1);
 	MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0xf9, read_buff, 15, 100);
+	
+	// Example for FLASH (blocking) (while(1)): write/read functions	
 #endif
 #ifdef EXT_EEPROM
-	// Example for EEPROM: writting MCU Program to external EEPROM
-	MEMSPI_RES = MEMSPI_EEPROM_Write(&hmemspi, 0, (uint8_t *)FLASH_BASE, FLASH_mcu_size, 2000, 0);
+	// Example for EEPROM (blocking): writting MCU Program to external EEPROM
+	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);
 	FLASH_read = 0x0;
 #endif
  while (1)
 	{
+		FLASH_read = FLASH_write;	
 #ifdef EXT_FLASH
-		// Example for FLASH: write/read functions
-		MEMSPI_RES = MEMSPI_FLASH_Write(&hmemspi, &writeInit, Timeout, 1);
-		MEMSPI_RES = MEMSPI_Read_Memory(&hmemspi, 0xf9, read_buff, 15, Timeout);
+		// Example for FLASH (blocking): write/read functions		
+		writeInit.fSavePrevoisData = 1;
+		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
 #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_Read_Memory(&hmemspi, 0+FLASH_read, read_buff, 15, Timeout);
 #endif
--- a/Example/MDK-ARM/flash
+++ b/Example/MDK-ARM/flash
@@ -152,9 +152,9 @@
        <Bp>
          <Number>0</Number>
          <Type>0</Type>
-          <LineNumber>156</LineNumber>
+          <LineNumber>151</LineNumber>
          <EnabledFlag>1</EnabledFlag>
-          <Address>134230216</Address>
+          <Address>134236100</Address>
          <ByteObject>0</ByteObject>
          <HtxType>0</HtxType>
          <ManyObjects>0</ManyObjects>
@@ -163,14 +163,14 @@
          <BreakIfRCount>1</BreakIfRCount>
          <Filename>../Core/Src/main.c</Filename>
          <ExecCommand></ExecCommand>
-          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\156</Expression>
+          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\151</Expression>
        </Bp>
        <Bp>
          <Number>1</Number>
          <Type>0</Type>
-          <LineNumber>160</LineNumber>
+          <LineNumber>146</LineNumber>
          <EnabledFlag>1</EnabledFlag>
-          <Address>134230308</Address>
+          <Address>134236064</Address>
          <ByteObject>0</ByteObject>
          <HtxType>0</HtxType>
          <ManyObjects>0</ManyObjects>
@@ -179,14 +179,14 @@
          <BreakIfRCount>1</BreakIfRCount>
          <Filename>../Core/Src/main.c</Filename>
          <ExecCommand></ExecCommand>
-          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\160</Expression>
+          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\146</Expression>
        </Bp>
        <Bp>
          <Number>2</Number>
          <Type>0</Type>
-          <LineNumber>169</LineNumber>
+          <LineNumber>144</LineNumber>
          <EnabledFlag>1</EnabledFlag>
-          <Address>134230310</Address>
+          <Address>134235990</Address>
          <ByteObject>0</ByteObject>
          <HtxType>0</HtxType>
          <ManyObjects>0</ManyObjects>
@@ -195,7 +195,7 @@
          <BreakIfRCount>1</BreakIfRCount>
          <Filename>../Core/Src/main.c</Filename>
          <ExecCommand></ExecCommand>
-          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\169</Expression>
+          <Expression>\\flash_eeprom_Example\../Core/Src/main.c\144</Expression>
        </Bp>
      </Breakpoint>
      <WatchWindow1>
@@ -212,7 +212,7 @@
        <Ww>
          <count>2</count>
          <WinNumber>1</WinNumber>
-          <ItemText>MEMSPI_RES</ItemText>
+          <ItemText>memspi_unique_ID</ItemText>
        </Ww>
        <Ww>
          <count>3</count>
@@ -286,12 +286,22 @@
          <WinNumber>2</WinNumber>
          <ItemText>&amp;0x20000760</ItemText>
        </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>
      <MemoryWindow1>
        <Mm>
          <WinNumber>1</WinNumber>
          <SubType>0</SubType>
-          <ItemText>0x08001532</ItemText>
+          <ItemText>0x08000100</ItemText>
          <AccSizeX>0</AccSizeX>
        </Mm>
      </MemoryWindow1>
@@ -299,7 +309,7 @@
        <Mm>
          <WinNumber>2</WinNumber>
          <SubType>0</SubType>
-          <ItemText>0x20000708</ItemText>
+          <ItemText>0x20001778</ItemText>
          <AccSizeX>0</AccSizeX>
        </Mm>
      </MemoryWindow2>
@@ -803,6 +813,30 @@
      <RteFlg>0</RteFlg>
      <bShared>0</bShared>
    </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>
--- a/Example/MDK-ARM/flash
+++ b/Example/MDK-ARM/flash
@@ -621,6 +621,16 @@
              <FileType>5</FileType>
              <FilePath>..\..\GENERAL\periph_general.h</FilePath>
            </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>
        </Group>
        <Group>
--- a/Example/flash
+++ b/Example/flash
@@ -11,7 +11,7 @@ Mcu.IP0=CRC
 Mcu.IP1=NVIC
 Mcu.IP2=RCC
 Mcu.IP3=RNG
-Mcu.IP4=SPI1
+Mcu.IP4=SPI2
 Mcu.IP5=SYS
 Mcu.IPNb=6
 Mcu.Name=STM32F407V(E-G)Tx
@@ -20,9 +20,9 @@ Mcu.Pin0=PH0-OSC_IN
 Mcu.Pin1=PH1-OSC_OUT
 Mcu.Pin10=VP_RNG_VS_RNG
 Mcu.Pin11=VP_SYS_VS_Systick
-Mcu.Pin2=PA5
-Mcu.Pin3=PA6
-Mcu.Pin4=PA7
+Mcu.Pin2=PB13
+Mcu.Pin3=PB14
+Mcu.Pin4=PB15
 Mcu.Pin5=PD12
 Mcu.Pin6=PD13
 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.SysTick_IRQn=true\:0\:0\:false\:false\:true\:true\:true\:false
 NVIC.UsageFault_IRQn=true\:0\:0\:false\:false\:true\:true\:false\:false
-PA5.Mode=Full_Duplex_Master
-PA5.Signal=SPI1_SCK
-PA6.Mode=Full_Duplex_Master
-PA6.Signal=SPI1_MISO
-PA7.Mode=Full_Duplex_Master
-PA7.Signal=SPI1_MOSI
+PB13.Locked=true
+PB13.Mode=Full_Duplex_Master
+PB13.Signal=SPI2_SCK
+PB14.Locked=true
+PB14.Mode=Full_Duplex_Master
+PB14.Signal=SPI2_MISO
+PB15.Locked=true
+PB15.Mode=Full_Duplex_Master
+PB15.Signal=SPI2_MOSI
 PD12.Locked=true
 PD12.Signal=GPIO_Output
 PD13.Locked=true
@@ -125,11 +128,11 @@ RCC.VCOI2SOutputFreq_Value=384000000
 RCC.VCOInputFreq_Value=2000000
 RCC.VCOOutputFreq_Value=128000000
 RCC.VcooutputI2S=192000000
-SPI1.CalculateBaudRate=4.0 MBits/s
-SPI1.Direction=SPI_DIRECTION_2LINES
-SPI1.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate
-SPI1.Mode=SPI_MODE_MASTER
-SPI1.VirtualType=VM_MASTER
+SPI2.CalculateBaudRate=4.0 MBits/s
+SPI2.Direction=SPI_DIRECTION_2LINES
+SPI2.IPParameters=VirtualType,Mode,Direction,CalculateBaudRate
+SPI2.Mode=SPI_MODE_MASTER
+SPI2.VirtualType=VM_MASTER
 VP_CRC_VS_CRC.Mode=CRC_Activate
 VP_CRC_VS_CRC.Signal=CRC_VS_CRC
 VP_RNG_VS_RNG.Mode=RNG_Activate
--- a/GENERAL/periph_general.h
+++ b/GENERAL/periph_general.h
@@ -1,5 +1,6 @@
 /********************************PERIPH*************************************
 Данный файл содержит инклюды и дефайны для всех библиотек базовой перефирии.
+Для использования библиотеки для периферии нужно подключить этот файл.
 ***************************************************************************/
 #ifndef __PERIPH_GENERAL_H_
 #define __PERIPH_GENERAL_H_
--- a/memory_spi/memory_spi.c
+++ b/memory_spi/memory_spi.c
@@ -34,8 +34,8 @@
 #include "memory_spi.h"
 uint8_t sector_buff[MEMSPI_SECTOR_SIZE];

-//-------------------------------------------------------------
-//--------------------------FOR USER---------------------------
+//-------------------------------------------------------------------
+//-----------------------------FOR USER------------------------------
 /**  
 	* @brief 	Initialize SPI and GPIO for MEMSPI FLASH.
 	* @param 	hmemspi - указатель на структуру с настройками SPI и GPIO портов.
@@ -72,7 +72,29 @@ void MEMSPI_Base_Init(MEMSPI_HandleTypeDef *hmemspi)
  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.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -190,7 +212,6 @@ HAL_StatusTypeDef MEMSPI_FLASH_Write(MEMSPI_HandleTypeDef *hmemspi, MEMSPI_Write
 	// WRITE FLASH WITH SAVING PREVIOUS DATA
 	if(WriteInit->fSavePrevoisData)
 	{
-//		uint8_t sector_buff[WriteInit->Sector_Size];
 		// store data from flash
 		MEMSPI_Status = MEMSPI_Read_Memory(hmemspi, WriteInit->Sector_Address, sector_buff, WriteInit->Sector_Size, Timeout);
 		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.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -508,6 +611,54 @@ HAL_StatusTypeDef MEMSPI_WriteEnablingUntilTimeout(MEMSPI_HandleTypeDef *hmemspi
 	* @note		Считывает флаги до тех пор, пока они не будут в состоянии FlagStatus или до тех пор, пока таймаут не истечет.
 	*/
 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;
 	// check flags
@@ -547,8 +698,9 @@ void MEMSPI_Update_Timeout_Variables(uint32_t *Timeout, uint32_t *tickstart)
 	*Timeout -= timeoutcnt;
 	*tickstart += timeoutcnt;	
 }
-//-------------------------------------------------------------
-//----------------------COMMAND FUNCTIONS----------------------
+//-------------------------------------------------------------------
+//-------------------------COMMAND FUNCTIONS-------------------------
+//------------------------------BLOCKING-----------------------------
 /** 
 	* @brief 	Send command to read Status Register.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -618,10 +770,8 @@ HAL_StatusTypeDef MEMSPI_CMD_Write_Status_Register(MEMSPI_HandleTypeDef *hmemspi
 	command[1] = WrittenBits;
 	command[2] = WrittenBits >> 8;

-	size = 3;
-
  MEMSPI_Select(hmemspi);
-  SPI_RES = MEMSPI_SPI_Transmit(hmemspi, command, size, Timeout);
+  SPI_RES = MEMSPI_SPI_Transmit(hmemspi, command, 3, Timeout);
  MEMSPI_Deselect(hmemspi);
 	
 	return SPI_RES;
@@ -645,7 +795,6 @@ HAL_StatusTypeDef MEMSPI_CMD_Write_Enable(MEMSPI_HandleTypeDef *hmemspi, uint32_
 	return SPI_RES;
 }

-
 /** 
 	* @brief 	Send command to read data from FLASH/EEPROM.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -659,7 +808,6 @@ HAL_StatusTypeDef MEMSPI_CMD_Read_Data(MEMSPI_HandleTypeDef *hmemspi, uint32_t F
 {
 	HAL_StatusTypeDef SPI_RES;
 	uint8_t command[4];
-	uint8_t response[2] = {0};
 	
  command[0] = MEMSPI_READ_DATA;
  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;
 }
-//-------------------------------------------------------------

+//-------------------------------------------------------------------
+//-------------------------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;
+}
--- a/memory_spi/memory_spi.h
+++ b/memory_spi/memory_spi.h
@@ -22,20 +22,22 @@
 /////////////////////////////////////////////////////////////////////
 ////////////////////////////---DEFINES---////////////////////////////
 /** 
-	* @brief 	SPI Transmit.
-	* @param 	_hmemspi_ - указатель на хендл внешней памяти.
-	* @param 	_data_ 		- указатель на данные для отправки.
-	* @param 	_size_ 		- размер данных для отправки.
-	* @param 	_timeout_	- время, за которое должна быть осуществлена отправка.
+	* @brief 	SPI Transmit IT.
 	* @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.
-	* @param 	_hmemspi_ - указатель на хендл внешней памяти.
-	* @param 	_data_ 		- указатель на буффер для прниема данных.
-	* @param 	_size_ 		- размер данных для приема.
-	* @param 	_timeout_	- время, за которое должен быть осуществлен прием.
 	* @note 	Здесь вызывается только функция HAL, и ничего больше.
 	*/
 #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;
 }MEMSPI_WriteInitTypeDef;

-typedef struct
+typedef enum
 {
-	uint16_t SR;
-	SPI_HandleTypeDef hspi;
-	GPIO_TypeDef 	*CS_GPIOx;
-	uint32_t			CS_PIN;
-	GPIO_TypeDef 	*CLK_GPIOx;
-	uint32_t			CLK_PIN;
-	GPIO_TypeDef 	*MISO_GPIOx;
-	uint32_t			MISO_PIN;
-	GPIO_TypeDef 	*MOSI_GPIOx;
-	uint32_t			MOSI_PIN;
-}MEMSPI_GPIOTypeDef;
+	WAIT_FOR_CMD			= 0x00,
+	WRITE_ENABLE    	= MEMSPI_WRITE_ENABLE,
+	WRITE_DISABLE    	= MEMSPI_WRITE_DISABLE,
+	WRITE_STATUS_REG  = MEMSPI_WRITE_STATUS_REG,
+
+	READ_DATA 				= MEMSPI_READ_DATA,
+	
+	ERASE_SECTOR    	= MEMSPI_ERASE_SECTOR,
+	PAGE_PROGRAM    	= MEMSPI_PAGE_PROGRAM,
+	WRITE_EEPROM    	= MEMSPI_WRITE_EEPROM,
+	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
 {
 	uint16_t SR;
-	SPI_SettingsTypeDef 	sspi;
-//	MEMSPI_GPIOTypeDef		GPIOs;
-	GPIO_TypeDef 					*CS_GPIOx;
-	uint32_t							CS_PIN;
-	uint32_t							hNextAddr;
-	uint16_t							hNextPage;
-	uint16_t							hNextSector;
+	
+	SPI_SettingsTypeDef 			sspi;	
+	GPIO_TypeDef 							*CS_GPIOx;
+	uint32_t									CS_PIN;
+	
+	MEM_OperationsTypeDef			Active_OP;
+	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;
 extern MEMSPI_HandleTypeDef hmemspi;

@@ -148,6 +178,17 @@ extern 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.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -285,8 +326,36 @@ HAL_StatusTypeDef MEMSPI_WaitOnFlagsUntilTimeout(MEMSPI_HandleTypeDef *hmemspi,
 void MEMSPI_Update_Timeout_Variables(uint32_t *Timeout, uint32_t *tickstart);
 ////////////////////////---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---/////////////////////
+////////////////////////////---BLOCKING---///////////////////////////
 /** 
 	* @brief 	Send command to read Status Register.
 	* @param 	hmemspi 			- указатель на хендл внешней памяти.
@@ -383,7 +452,100 @@ uint64_t MEMSPI_CMD_Read_Device_ID(MEMSPI_HandleTypeDef *hmemspi, uint32_t Timeo
 	* @note		Данная функция предполагает отправку одного dummy байта после адресса, но у меня поч не работает пока :(
 	*/
 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---/////////////////////
+///////////////////////////---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_
Author	SHA1	Message	Date
alexey	7133e63633	Добавлены проверки на режим прерывания (пока ниче не работает)	2024-08-14 18:28:35 +03:00
alexey	fd7d230e10	Начало работы над прерываниями	2024-08-14 18:27:50 +03:00