static void SPIx_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLegnth)
{
    HAL_StatusTypeDef status = HAL_OK;

    /* Check the communication status */
    status = HAL_SPI_TransmitReceive(&hspi1, (uint8_t*) DataIn, DataOut, DataLegnth, SpixTimeout);
   if (status != HAL_OK)
   {
      /* Execute user timeout callback */
      SPIx_Error();
   }   
}

static void SPIx_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLegnth)
{
    HAL_StatusTypeDef status = HAL_OK;
   if(DataLegnth<65)
   {
      status = HAL_SPI_TransmitReceive(&hspi1, (uint8_t*) DataIn, DataOut, DataLegnth, SpixTimeout);
             if (status != HAL_OK)
      {
         /* Execute user timeout callback */
         SPIx_Error();
      }
   }
   else
   {
      status = HAL_SPI_TransmitReceive_DMA(&hspi1, (uint8_t*) DataIn, DataOut, DataLegnth);
      if (status != HAL_OK)
      {
         /* Execute user timeout callback */
         SPIx_Error();
      }
      while(HAL_DMA_GetState(&hdma_spi1_tx) != HAL_DMA_STATE_READY);
   }   
}

/**
 * @brief  Reads block(s) from a specified address in the SD card, in polling mode.
 * @param  pData: Pointer to the buffer that will contain the data to transmit
 * @param  ReadAddr: Address from where data is to be read
 * @param  BlockSize: SD card data block size, that should be 512
 * @param  NumOfBlocks: Number of SD blocks to read
 * @retval SD status
 */
uint8_t BSP_SD_ReadBlocks(uint32_t* pData, uint32_t ReadAddr, uint16_t BlockSize, uint32_t NumberOfBlocks)
{
    uint32_t offset = 0;
    uint8_t retr = BSP_SD_ERROR;
    uint8_t *ptr = NULL;
    SD_CmdAnswer_typedef response;
    uint8_t block[BlockSize];

      
   
    /* Send CMD16 (SD_CMD_SET_BLOCKLEN) to set the size of the block and
     Check if the SD acknowledged the set block length command: R1 response (0x00: no errors) */
    response = SD_SendCmd(SD_CMD_SET_BLOCKLEN, BlockSize, 0xFF, SD_ANSWER_R1_EXPECTED);
    SD_IO_CSState(1);
    SD_IO_WriteByte(SD_DUMMY_BYTE);
    if (response.r1 != SD_R1_NO_ERROR)
    {
        goto error;
    }
      
/* это я закоментил      

    //ptr = malloc(sizeof(uint8_t) * BlockSize);
    ptr = (uint8_t *) &block;
//    if (ptr == NULL)
//    {
//        goto error;
//    }

      // visnet tut
   
    memset(ptr, SD_DUMMY_BYTE, sizeof(uint8_t) * BlockSize);
   
*/
   
   ptr = (uint8_t *) &block;
   //memset(ptr, SD_DUMMY_BYTE,  BlockSize);

      
      
    /* Data transfer */
    while (NumberOfBlocks--)
    {
        /* Send CMD17 (SD_CMD_READ_SINGLE_BLOCK) to read one block */
        /* Check if the SD acknowledged the read block command: R1 response (0x00: no errors) */
        response = SD_SendCmd(SD_CMD_READ_SINGLE_BLOCK, (ReadAddr + offset) / (flag_SDHC == 1 ? BlockSize : 1), 0xFF,
                SD_ANSWER_R1_EXPECTED);
        if (response.r1 != SD_R1_NO_ERROR)
        {
            goto error;
        }

        /* Now look for the data token to signify the start of the data */
        if (SD_WaitData(SD_TOKEN_START_DATA_SINGLE_BLOCK_READ) == BSP_SD_OK)
        {
            /* Read the SD block data : read NumByteToRead data */
            SD_IO_WriteReadData(ptr, (uint8_t*) pData + offset, BlockSize);

            /* Set next read address*/
            offset += BlockSize;
            /* get CRC bytes (not really needed by us, but required by SD) */
            SD_IO_WriteByte(SD_DUMMY_BYTE);
            SD_IO_WriteByte(SD_DUMMY_BYTE);
        }
        else
        {
            goto error;
        }

        /* End the command data read cycle */
        SD_IO_CSState(1);
        SD_IO_WriteByte(SD_DUMMY_BYTE);
    }

//    if (ptr != NULL)
//        free(ptr);
    retr = BSP_SD_OK;

    error:
    /* Send dummy byte: 8 Clock pulses of delay */
    SD_IO_CSState(1);
    SD_IO_WriteByte(SD_DUMMY_BYTE);
      
//    if (ptr != NULL)
//        free(ptr);

    /* Return the reponse */
    return retr;
}

void Ram_SetAddr(uint32_t addr)
{
   GPIOC->ODR = addr&0xFFFF;
   
   if(addr&(1<<16))
   {
      HAL_GPIO_WritePin(RamA16_GPIO_Port, RamA16_Pin, GPIO_PIN_SET);
      
   }
   else
   {
      HAL_GPIO_WritePin(RamA16_GPIO_Port, RamA16_Pin, GPIO_PIN_RESET);
      
   }
   
   if(addr&(1<<17))
   {
      HAL_GPIO_WritePin(RamA17_GPIO_Port, RamA17_Pin, GPIO_PIN_SET);
      
   }
   else
   {
      HAL_GPIO_WritePin(RamA17_GPIO_Port, RamA17_Pin, GPIO_PIN_RESET);
      
   }
   
   if(addr&(1<<18))
   {
      HAL_GPIO_WritePin(RamA18_GPIO_Port, RamA18_Pin, GPIO_PIN_SET);
      
   }
   else
   {
      HAL_GPIO_WritePin(RamA18_GPIO_Port, RamA18_Pin, GPIO_PIN_RESET);
      
   }
}

void RamDelay()
{
   uint16_t a=0;
   for(a=0;a<20;a++)
   {
      
   }
}

void Ram_Write(char* buf, uint32_t addr, uint32_t length)
{
   uint32_t EndAddr = addr + length;
   char data=0;
   uint32_t ClrA = 0xFF << 16;
   GPIO_InitTypeDef GPIO_InitStruct;
   
   //HAL_GPIO_WritePin(RamCE_GPIO_Port, RamCE_Pin, GPIO_PIN_SET);
   Ram_CE_1
   Ram_OE_1
   
   /*
   
   GPIO_InitStruct.Pin = RamA14_Pin|RamA15_Pin|RamA16_Pin|RamA0_Pin
                          |RamA1_Pin|RamA2_Pin|RamA3_Pin|RamA4_Pin
                          |RamA5_Pin|RamA6_Pin|RamA7_Pin|RamA8_Pin
                          |RamA9_Pin;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
   
   
   */
   
   
   GPIO_InitStruct.Pin = RamD0_Pin|RamD1_Pin|RamD2_Pin|RamD3_Pin
                   |RamD4_Pin|RamD5_Pin|RamD6_Pin|RamD7_Pin;
                  
   GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
   GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
   
   GPIOA->BSRR = ClrA;
   
   do
   {
      Ram_CE_1
      Ram_SetAddr(addr);
      
      data = *buf;
      
      GPIOA->BSRR = data&0xFF;
      
      RamDelay();
      
      Ram_CE_0
      
      Ram_WE_0
      
      RamDelay();
      
      Ram_WE_1
      
      buf++;
      
      GPIOA->BSRR = ClrA;
      
      addr++;
   }while(addr<EndAddr);
   
   GPIOA->BSRR = ClrA;
   GPIOC->BSRR = (uint32_t)(0xFFFF)<<16;   
}


void Ram_Read(char* buf, uint32_t addr, uint32_t length)
{
   uint32_t EndAddr = addr + length;
   uint32_t ClrA = 0xFF;
   uint32_t ClrC = 0xFFFF;
   
   GPIO_InitTypeDef GPIO_InitStruct;
   
   ClrA = ClrA<<16;
   ClrC = ClrC<<16;
   
   //HAL_GPIO_WritePin(RamCE_GPIO_Port, RamCE_Pin, GPIO_PIN_SET);
   Ram_CE_1
   Ram_OE_1
      
   GPIO_InitStruct.Pin = RamD0_Pin|RamD1_Pin|RamD2_Pin|RamD3_Pin
                   |RamD4_Pin|RamD5_Pin|RamD6_Pin|RamD7_Pin;
                  
   GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
   //GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
   GPIO_InitStruct.Pull = GPIO_NOPULL;
   HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
   
   GPIOA->BSRR = ClrA;
   
   do
   {
       Ram_CE_1
      
      Ram_SetAddr(addr);
      
      //GPIOA->BSRR = data&0xFF;
      
      Ram_CE_0
      
      Ram_OE_0
      
      RamDelay();
      
      *buf = GPIOA->IDR&0xFF;
      
      Ram_CE_1
      
      Ram_OE_1      
      
      buf++;
      addr++;
      
   }while(addr<EndAddr);
   *buf = 0;
   
   GPIOA->BSRR = ClrA;
   GPIOC->BSRR = ClrC;   
}

void InitClk()
{
    unsigned long int TimeOut = 10000;
    //Запустить HSE
    RCC->CR   |=  RCC_CR_HSEON;            //Включить генератор HSE
    while((RCC->CR & RCC_CR_HSERDY)==0)    //Ожидание готовности HSE
        if(TimeOut) TimeOut--;
    if(TimeOut==0) return;               //Ошибка!!! Генератор HSE не запустился
    RCC->CR   |=  RCC_CR_CSSON;            //Разрешить работу системы защиты сбоя HSE
    RCC->CFGR &= ~RCC_CFGR_PLLXTPRE;       //Не использовать делитель HSE
    //Частота  SystemCoreClock выше 24 MHz - разрешить буфер предварительной выборки FLASH
    FLASH->ACR|=  FLASH_ACR_PRFTBE;        //Включить буфер предварительной выборки
    FLASH->ACR&= ~FLASH_ACR_LATENCY;       //Очистить FLASH_ACR_LATENCY
    FLASH->ACR |= FLASH_ACR_LATENCY_2;     //Пропускать 2 такта
    //Настройка PLL
    RCC->CFGR  |= RCC_CFGR_PLLSRC;         //Источником сигнала для PLL выбран HSE
    RCC->CR   &= ~RCC_CR_PLLON;            //Отключить генератор PLL
    RCC->CFGR &= ~RCC_CFGR_PLLMULL;        //Очистить PLLMULL
    RCC->CFGR |=  RCC_CFGR_PLLMULL9;       //Коефициент умножения = 9
    RCC->CR   |=  RCC_CR_PLLON;            //Включить генератор PLL
    while((RCC->CR & RCC_CR_PLLRDY)==0) {} //Ожидание готовности PLL
    //Переключиться на тактирование от PLL
    RCC->CFGR &= ~RCC_CFGR_SW;             //Очистка битов выбора источника тактового сигнала
    RCC->CFGR |=  RCC_CFGR_SW_PLL;         //Выбрать источником тактового сигнала PLL
    while((RCC->CFGR&RCC_CFGR_SWS)!=0x08) {} //Ожидание переключения на PLL
    //Настроить делитель для шины APB1
    RCC->CFGR &= ~RCC_CFGR_PPRE1;          //Очистка битов предделителя "APB1 Prescaler"
    RCC->CFGR |=  RCC_CFGR_PPRE1_DIV4;     //Установить "APB1 Prescaler" равным 4
    //Настроить делитель для шины APB2
    RCC->CFGR &= ~RCC_CFGR_PPRE2;          //Очистка битов предделителя "APB2 Prescaler"
    RCC->CFGR |=  RCC_CFGR_PPRE2_DIV4;     //Установить "APB2 Prescaler" равным 4
}