Пн сен 25, 2017 22:28:23
static void SPIx_WriteReadData(const uint8_t *DataIn, uint8_t *DataOut, uint16_t DataLegnth)
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 *) █
// if (ptr == NULL)
// {
// goto error;
// }
// visnet tut
memset(ptr, SD_DUMMY_BYTE, sizeof(uint8_t) * BlockSize);
*/
ptr = (uint8_t *) █
//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;
}
memset(ptr, SD_DUMMY_BYTE, sizeof(uint8_t) * BlockSize);
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;
}
Вт сен 26, 2017 09:18:00
Вт сен 26, 2017 10:46:31
Вт сен 26, 2017 10:56:11
Вт сен 26, 2017 11:00:28
Вт сен 26, 2017 11:37:26
Вт сен 26, 2017 13:26:45
Ср сен 27, 2017 13:45:35
Ср сен 27, 2017 14:50:42
Ср сен 27, 2017 14:59:01
Ср сен 27, 2017 15:04:34
Ср сен 27, 2017 15:34:49
Ср сен 27, 2017 15:58:50
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
}
Чт сен 28, 2017 07:33:46
char LineTimerUpdEn = 0;
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
if(htim->Instance == TIM3)
{
LineTimerUpdEn++;
if(GPIOA->ODR & GPIO_PIN_12)
{
GPIOA->BSRR = GPIO_PIN_12<<16;
}
else
{
GPIOA->BSRR = GPIO_PIN_12;
}
}
}
while(HAL_DMA_GetState(&hdma_spi2_tx) != HAL_DMA_STATE_READY);
while(LineTimerUpdEn == 0);
LineTimerUpdEn=0;
while(LineTimerUpdEn == 0)
{
__nop();
__nop();
__nop();
__nop();
__nop();
}
Чт сен 28, 2017 07:42:31
volatile char LineTimerUpdEn = 0;
Чт сен 28, 2017 14:02:31
Чт сен 28, 2017 14:22:23
Чт сен 28, 2017 17:45:27
Чт сен 28, 2017 18:48:36
Чт сен 28, 2017 20:33:21