Operación SPI de la biblioteca de firmware stm32
Funcionamiento SPI de la biblioteca de firmware stm32
Fuente: Wildfirelt Juega con STM32-F407gt sin puntos ciegos
'''
/ * Definición de tipo privada ---------------------------------------------- - ------------*/
//#define sFLASH_ID 0xEF3015 //W25X16
//#define sFLASH_ID 0xEF4015 //W25Q16
//#define sFLASH_ID 0XEF4017 //W25Q64
//#define SPI_FLASH_PageSize 4096
/* Definición privada ------------- ----------------------------------------------- /
/Definición de comando-comienzo*********************************/
/* Definición del comando - fin *******************************/
/*Definición de la interfaz SPI - comienzo *******************************/
/*definición de interfaz SPI-fin*** *** **********************/
/Tiempo de espera de espera/
/Salida de información/
==============================
estático __IO uint32_t SPITimeout = SPIT_LONG_TIMEOUT
static uint16_t SPI_TIMEOUT_UserCallback(uint8_t errorCode);
/**
/* Habilitar reloj FLASH_SPI y GPIO/
/ !lt; , SPI_FLASH_SPI_MOSI_GPIO,
SPI_FLASH_SPI_MISO_GPIO, SPI_FLASH_SPI_SCK_GPIO reloj habilitado*/
RCC_AHB1PeriphClockCmd (FLASH_SPI_SCK_GPIO_CLK|FLASH_SPI_MOSI_GPIO_CLK|FL ASH_CS_GPIO_CLK, ENABLE
/*!lt; SPI_FLASH_SPI Reloj habilitar*/
FLASH_SPI_CLK_INIT(FLASH_SPI_CLK, ENABLE
; _AF);
GPIO_PinAFConfig(FLASH_SPI_MOSI_GPIO_PORT, FLASH_SPI_MOSI_PINSOURCE, FLASH_SPI_MOSI_AF);
/*!lt; Configurar el pin SPI_FLASH_SPI: SCK */
GPIO_InitStructure.GPIO_Pin = FLASH_SPI_SCK_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(FLASH_SPI_SCK_GPIO_PORT, y GPIO_InitStructure
GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MISO_PIN
GPIO_Init(FLASH_SPI_MISO_GP); IO_PORT, y GPIO_InitStructure)
GPIO_InitStructure.GPIO_Pin = FLASH_SPI_MOSI_PIN;
GPIO_Init(FLASH_SPI_MOSI_GPIO_PORT, & GPIO_InitStructure
GPIO_InitStructure.GPIO_Pin = FLASH_CS_PIN; .GPIO_Mode = GPIO_Mode_OUT ;
GPIO_Init(FLASH_CS_GPIO_PORT, amp; GPIO_InitStructure);
/* Señal de parada FLASH: nivel alto del pin CS*/
SPI_FLASH_CS_HIGH()
/* Configuración del modo FLASH_SPI*/
// El chip FLASH admite el modo SPI 0 y el modo 3, configure CPOL CPHA en consecuencia
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex ;
SPI_InitStructure.SPI_Mode = SPI_Mode_Ma
ster;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure. SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(FLASH_SPI, amp; SPI_InitStructure);
/* Habilitar FLASH_SPI */
SPI_Cmd(FLASH_SPI, ENABLE
}
< p); > /**/**
/* Borrar bloque completo /
/ Seleccionar FLASH: CS nivel bajo/
SPI_FLASH_CS_LOW ();
/ Enviar comando de borrado de bloque/
SPI_FLASH_SendByte(W25X_ChipErase);
/ Señal de parada FLASH: CS nivel alto*/
SPI_FLASH_CS_HIGH();
/* Esperar a que se complete el borrado*/
SPI_FLASH_WaitForWriteEnd()
}
/* *
/* Seleccione FLASH: CS nivel bajo/
SPI_FLASH_CS_LOW()
/ Escribir comando de escritura de página/
SPI_FLASH_SendByte( W25X_PageProgram);
/ Envía el bit alto de la dirección de escritura/
SPI_FLASH_SendByte((WriteAddr amp; 0xFF0000) gt; gt; 16
); Envía el bit medio de la dirección de escritura/
SPI_FLASH_SendByte((WriteAddr amp; 0xFF00) gt; gt; 8);
/ Envía el bit bajo de la dirección de escritura*/
SPI_FLASH_SendByte(WriteAddr amp; 0xFF);
if(NumByteToWrite gt; SPI_FLASH_PerWritePageSize)
{
NumByteToWrite = SPI_FLASH_PerWritePageSize
FLASH_ERROR("SPI_FLASH_PageWrite
¡demasiado grande!");
}
/* Escribir datos/
while (NumByteToWrite--)
{
/ Envía los datos del byte actual para escribir/
SPI_FLASH_SendByte( pBuffer);
/* Apunta al siguiente byte de datos*/
pBuffer;
}
/* Señal de parada FLASH: CS nivel alto*/
SPI_FLASH_CS_HIGH()
/ * Espera para completar la escritura*/
SPI_FLASH_WaitForWriteEnd();
}
/**
/**
/* Enviar comando de lectura*/
SPI_FLASH_SendByte(W25X_ReadData);
/* Enviar bit alto de dirección de lectura/
SPI_FLASH_SendByte((ReadAddr amp. 0xFF0000 ) gt; gt; 16);
/ Enviar el bit central de la dirección de lectura/
SPI_FLASH_SendByte((ReadAddramp; 0xFF00) gt; gt; 8); >
/Enviar el bit bajo de la dirección de lectura*/
SPI_FLASH_SendByte(ReadAddr amp; 0xFF
while (NumByteToRead--)
{
/* Leer un byte*/
pBuffer = SPI_FLASH_SendByte(Dummy_Byte);
/ Apunta al siguiente búfer de bytes*/
pBuffer;
}
/* Señal de parada FLASH: CS nivel alto*/
SPI_FLASH_CS_HIGH()
}
/**
/* Iniciar comunicación: CS nivel bajo*/
SPI_FLASH_CS_LOW()
/* Enviar comando JEDEC y leer ID */
SPI_FLASH_SendByte(W25X_JedecDeviceID);
/* Leer un byte de datos*/
Temp0 = SPI_FLASH_SendByte(Dummy_Byte);
/* Leer un byte de datos*/
Temp1 = SPI_FLASH_SendByte(Dummy_Byte
/* Leer un byte de datos*/
Temp2); = SPI_FLASH_SendByte(Dummy_Byte);
/* Detener comunicación: CS nivel alto*/
SPI_FLASH_CS_HIGH()
Temp = (Temp0 lt; lt ; 16 ) | (Temp1 l
t; lt; 8) | Temp2;
retorno Temp;
/**
/* Seleccione FLASH: Selección de chip baja */
SPI_FLASH_CS_LOW();
/* Enviar instrucción "RDID " */
SPI_FLASH_SendByte(W25X_DeviceID
SPI_FLASH_SendByte(Dummy_Byte);
SPI_FLASH_SendByte(Dummy_Byte);
/* Leer un byte del FLASH */
Temp = SPI_FLASH_SendByte(Dummy_Byte);
/* Deseleccionar FLASH: Chip Seleccionar alto */
SPI_FLASH_CS_HIGH()
return Temp;
}
/************************************ **********************************************
/**
/**
/* Esperando a que el búfer de envío esté vacío, evento TXE*/
while (SPI_I2S_GetFlagStatus(FLASH_SPI, SPI_I2S_FLAG_TXE) == RESET)
{
if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(0);
}
;/* Escribe el registro de datos y escribe los datos que se escribirán en el búfer de envío*/
SPI_I2S_SendData(FLASH_SPI, byte);
SPITimeout = SPIT_FLAG_TIMEOUT
/* Espere a que el búfer de recepción no esté vacío, evento RXNE*/
while (SPI_I2S_GetFlagStatus(FLASH_SPI, SPI_I2S_FLAG_RXNE) == RESET)
{
if((SPITimeout--) == 0) return SPI_TIMEOUT_UserCallback(1);
}
/* Lee el registro de datos y obtiene los datos del búfer de recepción* /
return SPI_I2S_ReceiveData(FLASH_SPI
}
/*********************; ********** **************************************** *********** ****
/**
/*
Enviar comando de habilitación de escritura*/
SPI_FLASH_SendByte(W25X_WriteEnable);
/*La comunicación finaliza: CS alta*/
SPI_FLASH_CS_HIGH();
}
/**
/* Seleccionar FLASH: CS Bajo*/
SPI_FLASH_CS_LOW()
/* Enviar leer comando de registro de estado*/
SPI_FLASH_SendByte(W25X_ReadStatusReg);
SPITimeout = SPIT_FLAG_TIMEOUT
/* Si FLASH está ocupado, espere/
do
{
/ Leer el registro de estado del chip FLASH*/
FLASH_Status = SPI_FLASH_SendByte(Dummy_Byte
); }
while ((FLASH_Status amp; WIP_Flag) == SET); /* Indicador de escritura*/
/* Señal de parada FLASH: CS alto*/
SPI_FLASH_CS_HIGH();
}
//Ingrese al modo de apagado
void SPI_Flash_PowerDown(void)
{
p>/* Seleccionar FLASH: CS low*/
SPI_FLASH_CS_LOW();
/* Enviar comando de apagado*/
SPI_FLASH_SendByte (W25X_PowerDown );
/* Señal de parada FLASH: CS alta*/
SPI_FLASH_CS_HIGH()
}
//Wake; arriba
void SPI_Flash_WAKEUP(void)
{
/*Seleccione FLASH: CS bajo*/
SPI_FLASH_CS_LOW()
/* Enviar comando de encendido*/
SPI_FLASH_SendByte(W25X_ReleasePowerDown);
/* Señal de parada FLASH: CS alto*/
SPI_FLASH_CS_HIGH() ; //Esperando TRES1
}
/**
================ ==== ==========
TestStatus Buffercmp(uint8_t* pBuffer1, uint8_t* pBuffer2, uint16_t BufferLength)
{
while(BufferLength- -)
{
if(*pBuffer1 != *pBuffer2
)
{
retorno FALLADO
}
}
retorno PASADO
}
void Delay(__IO uint32_t nCount)
{
for(; nCount != 0; nCount--); p> }
//main
/* Inicialización del flash serie W25Q128 de 16M*/
SPI_FLASH_Init()
'' '