void Out_Data_SPI3(uint16_t SPI_Data)
{
SPI_SSOutputCmd(SPI3,DISABLE);
SPI_Cmd(SPI3, ENABLE);
SPI_I2S_SendData(SPI3, SPI_Data);
SPI_SSOutputCmd(SPI3,ENABLE);
SPI_Cmd(SPI3, DISABLE);
Delay(50);
}
uint16_t In_Data_SPI3(void)
{
uint16_t SPI_Data;
SPI_SSOutputCmd(SPI3,DISABLE);
SPI_Cmd(SPI3, ENABLE);
SPI_Data = SPI_I2S_ReceiveData(SPI3);
SPI_SSOutputCmd(SPI3,ENABLE);
SPI_Cmd(SPI3, DISABLE);
Delay(50);
return SPI_Data;
}
void CMasterSPIHardware::init( SPI_TypeDef * hard_spi, const hard_SPI_config * config )
{
SPI_InitTypeDef SPI_InitStructure;
_spi = hard_spi;
if (hard_spi == SPI1)
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
else if (hard_spi == SPI2)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
SPI_I2S_DeInit(hard_spi);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_DataSize = (config->num_of_bit - 1) << 8;
SPI_InitStructure.SPI_CPOL = config->CPOL;
SPI_InitStructure.SPI_CPHA = config->CPHA;
SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
SPI_InitStructure.SPI_BaudRatePrescaler = config->prescaller;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(hard_spi, &SPI_InitStructure);
SPI_SSOutputCmd(hard_spi, ENABLE);
SPI_NSSPulseModeCmd(hard_spi, ENABLE);
/* Initialize the FIFO threshold */
SPI_RxFIFOThresholdConfig(hard_spi, SPI_RxFIFOThreshold_QF);
/* Enable the SPI peripheral */
SPI_Cmd(hard_spi, ENABLE);
}
void ZigBee_InitSpi()
{
RCC_APB1PeriphClockCmd(MAKENAME(RCC_APB1Periph_SPI,ZIGBEE_SPI), ENABLE);
// SPI initialization
SPI_InitTypeDef SPI_InitStructure;
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(MAKENAME(SPI,ZIGBEE_SPI), &SPI_InitStructure);
SPI_SSOutputCmd(MAKENAME(SPI,ZIGBEE_SPI), ENABLE); // MOST IMPORTANT LINE FOR SPI !!!!
SPI_RxFIFOThresholdConfig(MAKENAME(SPI,ZIGBEE_SPI), SPI_RxFIFOThreshold_QF);
SPI_Cmd(MAKENAME(SPI,ZIGBEE_SPI), ENABLE);
/*
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = MAKENAME(SPI,ZIGBEE_SPI)_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
*/
}
void InitialiseSPI()
{
SPI_InitTypeDef SPI_InitStruct;
GPIO_PinAFConfig(GPIOA,GPIO_PinSource5,GPIO_AF_0);
GPIO_PinAFConfig(GPIOA,GPIO_PinSource6,GPIO_AF_0);
GPIO_PinAFConfig(GPIOA,GPIO_PinSource7,GPIO_AF_0);
//Set CS high
GPIO_SetBits(GPIOA,GPIO_Pin_4);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low; //Clock is low when idle
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge; //Data sampled at 1st edge
SPI_InitStruct.SPI_NSS = SPI_NSS_Hard; //Was Soft
SPI_InitStruct.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_256;
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_Init(SPI1, &SPI_InitStruct);
SPI_SSOutputCmd(SPI1,ENABLE);
SPI_Cmd(SPI1, ENABLE);
}
/************************************************************************************//*
* @ breif: a simple code segment to show how to config the spi as master mode.
* @ in: none
* @ return: none
**************************************************************************************/
void SPI_MasterMode_Init(void)
{
SPI_InitTypeDef SPI_InitStructure;
/* Enable AFIO & SPI SEL pin port & SPI clock */
CKCU_APBPerip0ClockConfig(CKCU_APBEN0_AFIO | CKCU_APBEN0_PB | CKCU_APBEN0_SPI, ENABLE);
/* Configure SPI SEL pin */
GPIO_SetOutBits(GPIOB, GPIO_PIN_7);
GPIO_DirectionConfig(GPIOB, GPIO_PIN_7, GPIO_DIR_OUT);
/* SPI Configuration */
SPI_InitStructure.SPI_Mode = SPI_MASTER;
SPI_InitStructure.SPI_FIFO = SPI_FIFO_DISABLE;
SPI_InitStructure.SPI_DataLength = SPI_DATALENGTH_8;
SPI_InitStructure.SPI_SSMode = SPI_SS_SOFTWARE;
SPI_InitStructure.SPI_SSPolarity = SPI_SSPOLARITY_LOW;
SPI_InitStructure.SPI_FirstBit = SPI_FIRSTBIT_MSB;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_HIGH;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_SECOND;
SPI_InitStructure.SPI_RxFIFOTriggerLevel = 0;
SPI_InitStructure.SPI_TxFIFOTriggerLevel = 0;
SPI_InitStructure.SPI_ClockPrescaler = 4;
SPI_Init(SPI, &SPI_InitStructure);
SPI_SSOutputCmd(SPI, ENABLE);
SPI_Cmd(SPI, ENABLE);
}
void keyLedInit(void) {
GPIO_InitTypeDef GPIO_InitStruct;
//CS
GPIO_InitStruct.GPIO_Pin = SPI_GPIOPIN_LED_CS;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_2;
GPIO_Init(SPI_GPIO_LED_CS, &GPIO_InitStruct);
//SPI CLK
GPIO_InitStruct.GPIO_Pin = SPI_GPIOPIN_LED_CLK;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_2;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SPI_GPIO_LED_CLK, &GPIO_InitStruct); //时钟gpio 端口模式
//SPI MOSI
GPIO_InitStruct.GPIO_Pin = SPI_GPIOPIN_LED_DATA;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_Level_2;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SPI_GPIO_LED_DATA, &GPIO_InitStruct);
//AF
//GPIO_PinAFConfig(SPI_GPIO_LED_CS, SPI_GPIOPIN_LED_CS_PINSOC, GPIO_AF_0);
GPIO_PinAFConfig(SPI_GPIO_LED_CLK, SPI_GPIOPIN_LED_CLK_PINSOC, GPIO_AF_0);
GPIO_PinAFConfig(SPI_GPIO_LED_DATA, SPI_GPIOPIN_LED_DATA_PINSOC, GPIO_AF_0);
//SpiCsDisable();
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
SPI_InitTypeDef SPI_InitStruct;
SPI_StructInit(&SPI_InitStruct);
SPI_InitStruct.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStruct.SPI_CRCPolynomial = 7;
SPI_Init(SPI2, &SPI_InitStruct);
SPI_SSOutputCmd(SPI2, ENABLE);
GPIO_SetBits(SPI_GPIO_LED_CS, SPI_GPIOPIN_LED_CS);
SPI_Cmd(SPI2, ENABLE);
keyLedSet(0xffff);
}
void spi_init()
{
GPIO_InitTypeDef gpioInitStruct;
GPIO_StructInit(&gpioInitStruct);
// configure pins used by SPI1
// PA5 = SCK
// PA6 = MISO
// PA7 = MOSI
gpioInitStruct.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
gpioInitStruct.GPIO_Mode = GPIO_Mode_AF_PP;
gpioInitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &gpioInitStruct);
// enable clock for used IO pins - already done in main
// CS
gpioInitStruct.GPIO_Pin = GPIO_Pin_0;
gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
gpioInitStruct.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &gpioInitStruct);
// RST
gpioInitStruct.GPIO_Pin = GPIO_Pin_1;
gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
gpioInitStruct.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &gpioInitStruct);
// DC
gpioInitStruct.GPIO_Pin = GPIO_Pin_2;
gpioInitStruct.GPIO_Mode = GPIO_Mode_Out_PP;
gpioInitStruct.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOA, &gpioInitStruct);
// enable SPI1 clock
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
SPI_InitTypeDef spi1;
SPI_StructInit(&spi1);
spi1.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi1.SPI_Mode = SPI_Mode_Master;
spi1.SPI_DataSize = SPI_DataSize_8b;
spi1.SPI_CPOL = SPI_CPOL_Low;
spi1.SPI_CPHA = SPI_CPHA_1Edge;
spi1.SPI_NSS = SPI_NSS_Soft;
spi1.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
spi1.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_Init(SPI1, &spi1);
SPI_SSOutputCmd(SPI1, DISABLE);
SPI_Cmd(SPI1, ENABLE);
}
/**
* Initialize SPI2 which is connected to cc2520 in OpenNode 2010 design. Other SPI
* operations should be sent after calling this function.
*/
void CC2520_SPI_OPEN(void)
{
SPI_Cmd(SPI2, DISABLE);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
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(SPI2, &SPI_InitStructure);
SPI2->CR1 &= 0xDFFF; //disable CRC
SPI_SSOutputCmd(SPI2, ENABLE);
SPI_Cmd( SPI2,ENABLE); //enable spi2
// @todo: to be organized
/*************todo*******************/
/*Enable SPI1.NSS as a GPIO*/
SPI_SSOutputCmd(SPI2, ENABLE);
/*Configure PA.4(NSS)--------------------------------------------
GPIO_InitStructure.GPIO_Pin =GPIO_Pin_12;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode=GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// **************todo********************
//start 2520
GPIO_ResetBits( GPIOB,GPIO_Pin_1);
hal_delayus( 100);
GPIO_SetBits( GPIOB,GPIO_Pin_1);
// *********************************/
}
void SPIClass::begin() {
// Start clock
if (SPIx == SPI1)
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
else if (SPIx == SPI2)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
else if (SPIx == SPI3)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
pinModeAlt(SCK, GPIO_OType_PP, GPIO_PuPd_DOWN, afSCK);
pinModeAlt(MISO, GPIO_OType_PP, GPIO_PuPd_DOWN, afMISO);
pinModeAlt(MOSI, GPIO_OType_PP, GPIO_PuPd_DOWN, afMOSI);
SPI_I2S_DeInit(SPIx);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = dataSize;
if(SPI_Data_Mode_Set != true) {
//Default: SPI_MODE0
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
}
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
if(SPI_Clock_Divider_Set != true) {
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
}
if(SPI_Bit_Order_Set != true) {
//Default: MSBFIRST
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
}
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPIx, &SPI_InitStructure);
// FIXME: the state of these settings doesn't seem to make sense...but it works for now.
SPI_SSOutputCmd(SPIx, ENABLE);
#if defined(SERIES_STM32F30x) || defined(SERIES_STM32F37x)
// Info here: http://stackoverflow.com/questions/22769920/stm32f0-spi-loopback-no-data-on-miso
if (dataSize == SPI_DataSize_16b)
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_HF);
else
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_QF);
#endif
SPI_Cmd(SPIx, ENABLE);
SPI_Enabled = true;
}
void ZigBee_InitSpi()
{
// SPI might be on APB1 (36 MHz) or APB2 (72 MHz)
#if defined(STM32F303xC)
#if ZIGBEE_SPI == 1
RCC_APB2PeriphClockCmd(MAKENAME(RCC_APB2Periph_SPI,ZIGBEE_SPI), ENABLE);
uint32_t baud_rate_prescaler = SPI_BaudRatePrescaler_16;
#elif ZIGBEE_SPI == 2 || ZIGBEE_SPI == 3
RCC_APB1PeriphClockCmd(MAKENAME(RCC_APB2Periph_SPI,ZIGBEE_SPI), ENABLE);
uint32_t baud_rate_prescaler = SPI_BaudRatePrescaler_8;
#endif
#elif defined(STM32F37X)
RCC_APB1PeriphClockCmd(MAKENAME(RCC_APB1Periph_SPI,ZIGBEE_SPI), ENABLE);
uint32_t baud_rate_prescaler = SPI_BaudRatePrescaler_8;
#else
#error("Unrecognized target. The Makefile should define one of the following: {STM32F37X, STM32F303xC}")
#endif
// SPI initialization
SPI_InitTypeDef SPI_InitStructure;
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = baud_rate_prescaler;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(MAKENAME(SPI,ZIGBEE_SPI), &SPI_InitStructure);
SPI_SSOutputCmd(MAKENAME(SPI,ZIGBEE_SPI), ENABLE); // MOST IMPORTANT LINE FOR SPI !!!!
SPI_RxFIFOThresholdConfig(MAKENAME(SPI,ZIGBEE_SPI), SPI_RxFIFOThreshold_QF);
SPI_Cmd(MAKENAME(SPI,ZIGBEE_SPI), ENABLE);
/*
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = MAKENAME(SPI,ZIGBEE_SPI)_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
*/
}
void SPI_Config(void)
{
//konfigurowanie interfejsu SPI
SPI_InitTypeDef SPI_InitStructure;
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx; //transmisja z wykorzystaniem jednej linii, transmisja jednokierunkowa
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave; //tryb pracy SPI
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b; //16-bit ramka danych
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; //stan sygnalu taktujacego przy braku transmisji - niski
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //aktywne zbocze sygnalu taktujacego - 1-sze zbocze
SPI_InitStructure.SPI_NSS = SPI_NSS_Hard; //sprzetowa obsluga linii NSS (CS)
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;//prescaler szybkosci tansmisji 36MHz/256=140.625kHz
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; //pierwszy bit w danych najbardziej znaczacy
SPI_InitStructure.SPI_CRCPolynomial = 7; //stopien wielomianu do obliczania sumy CRC
SPI_Init(SPI1, &SPI_InitStructure); //inicjalizacja SPI
SPI_SSOutputCmd(SPI1, ENABLE);
SPI_Cmd(SPI1, ENABLE); // Wlacz SPI1
}
void SPI_f207Config(void)
{
SPI_InitTypeDef SPI_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
SPI_f207GPIO_Config();
SPI_Cmd(SPI3, ENABLE);
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 0;
SPI_Init(SPI3,&SPI_InitStructure);
SPI_SSOutputCmd(SPI3,DISABLE);
SPI_I2S_DMACmd(SPI3,SPI_I2S_DMAReq_Tx, ENABLE);
SPI_TxDma_Config();
}
void SPI_Config(void)
{
SPI_GPIO_Config();
SPI_InitTypeDef SPI_InitStructure;
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
SPI_I2S_DeInit(SPI3);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 0;
SPI_Init(SPI3, &SPI_InitStructure);
SPI_SSOutputCmd(SPI3,DISABLE);
SPI_NSSInternalSoftwareConfig(SPI1, SPI_NSSInternalSoft_Set);
SPI_Cmd(SPI3, ENABLE);
SPI3->DR = DLE;
}
// Blocking SPI transfer
static void spi_transfer() {
// Enable NSS output for master mode
SPI_SSOutputCmd(SPI1, ENABLE);
// Enable DMA1 Channel1 Transfer Complete interrupt
//DMA_ITConfig(SPI1_TX_DMA_CHANNEL, DMA_IT_TC, ENABLE);
// Enable the DMA channels
SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, ENABLE);
SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, ENABLE);
DMA_Cmd(SPI1_RX_DMA_CHANNEL, ENABLE);
DMA_Cmd(SPI1_TX_DMA_CHANNEL, ENABLE);
// Wait for everything to finish
//TODO: Implement timeout so we don't get stuck
//uint32_t TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPI1_RX_DMA_FLAG_TC) == RESET));
while ((DMA_GetFlagStatus(SPI1_TX_DMA_FLAG_TC) == RESET));
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
while ((SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET));
while ((SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_BSY) == SET));
// End the SPI transaction and DMA
// Clear DMA1 global flags
DMA_ClearFlag(SPI1_TX_DMA_FLAG_GL);
DMA_ClearFlag(SPI1_RX_DMA_FLAG_GL);
// Disable the DMA channels
DMA_Cmd(SPI1_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(SPI1_TX_DMA_CHANNEL, DISABLE);
// Disable the SPI Rx and Tx DMA requests
SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Rx, DISABLE);
SPI_I2S_DMACmd(SPI1, SPI_I2S_DMAReq_Tx, DISABLE);
}
/**
* @brief 根据外部SPI设备配置SPI相关参数
* @param SPIx 需要使用的SPI
* @retval None
*/
void SPI_Configuration(SPI_TypeDef* SPIx)
{
SPI_InitTypeDef SPI_InitStruct;
SPI_RCC_Configuration(SPIx,0);
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32; //波特率预分频值为32 Chain提示此处注意，通信时钟由主SPI的时钟分配而得，不需要设置从SPI的时钟
SPI_InitStruct.SPI_Direction= SPI_Direction_2Lines_FullDuplex; //双线双向全双工
SPI_InitStruct.SPI_Mode = SPI_Mode_Master; //主SPI设备
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; //SPI数据大小
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low; //时钟悬空低
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge; //数据捕获与第一个时钟沿
SPI_InitStruct.SPI_NSS = SPI_NSS_Hard; //NSS由外部管脚管理
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB; //数据传输从MSB开始
SPI_InitStruct.SPI_CRCPolynomial = 7; //定义用于CRC值计算的多项式
SPI_Init(SPIx, &SPI_InitStruct); //配置以上SPI的配置
SPI_GPIO_Configuration(SPIx,0);
SPI_SSOutputCmd(SPIx, ENABLE); //使能指定的SPI SS输出
SPI_Cmd(SPIx, ENABLE); //使能SPI外设
}
/**
* @brief Main program
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f10x_xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f10x.c file
*/
/* System clocks configuration ---------------------------------------------*/
RCC_Configuration();
/* GPIO configuration ------------------------------------------------------*/
GPIO_Configuration();
/* SPI_SLAVE_Rx_DMA_Channel configuration ---------------------------------------------*/
DMA_DeInit(SPI_SLAVE_Rx_DMA_Channel);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPI_SLAVE_DR_Base;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)SPI_SLAVE_Buffer_Rx;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = BufferSize;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(SPI_SLAVE_Rx_DMA_Channel, &DMA_InitStructure);
/* SPI_MASTER configuration ------------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Tx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Hard;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI_MASTER, &SPI_InitStructure);
/* SPI_SLAVE configuration ------------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_1Line_Rx;
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPI_SLAVE, &SPI_InitStructure);
/* Enable SPI_MASTER NSS output for master mode */
SPI_SSOutputCmd(SPI_MASTER, ENABLE);
/* Enable SPI_SLAVE Rx request */
SPI_I2S_DMACmd(SPI_SLAVE, SPI_I2S_DMAReq_Rx, ENABLE);
/* Enable SPI_SLAVE */
SPI_Cmd(SPI_SLAVE, ENABLE);
/* Enable SPI_MASTER */
SPI_Cmd(SPI_MASTER, ENABLE);
/* Enable DMA1 Channel4 */
DMA_Cmd(SPI_SLAVE_Rx_DMA_Channel, ENABLE);
/* Transfer procedure */
while (TxIdx < BufferSize)
{
/* Wait for SPI_MASTER Tx buffer empty */
while (SPI_I2S_GetFlagStatus(SPI_MASTER, SPI_I2S_FLAG_TXE) == RESET);
/* Send SPI_MASTER data */
SPI_I2S_SendData(SPI_MASTER, SPI_MASTER_Buffer_Tx[TxIdx++]);
}
/* Wait for DMA1 channel4 transfer complete */
while (!DMA_GetFlagStatus(SPI_SLAVE_Rx_DMA_FLAG));
/* Check the corectness of written data */
TransferStatus = Buffercmp(SPI_SLAVE_Buffer_Rx, SPI_MASTER_Buffer_Tx, BufferSize);
/* TransferStatus = PASSED, if the transmitted and received data
are equal */
/* TransferStatus = FAILED, if the transmitted and received data
are different */
while (1)
{}
}
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f0xx.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f0xx.c file
*/
/* SPI configuration ------------------------------------------------------*/
SPI_Config();
/* SysTick configuration ---------------------------------------------------*/
SysTickConfig();
/* Initialize LEDs mounted on STM320518-EVAL board */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
/* Master board configuration ------------------------------------------------*/
#ifdef SPI_MASTER
/* Initialize push-buttons mounted on STM320518-EVAL board */
STM_EVAL_PBInit(BUTTON_RIGHT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_LEFT, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_UP, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_DOWN, BUTTON_MODE_GPIO);
STM_EVAL_PBInit(BUTTON_SEL, BUTTON_MODE_GPIO);
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPIx, &SPI_InitStructure);
/* Initialize the FIFO threshold */
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_QF);
/* TIM configuration ------------------------------------------------------*/
TIM_Config();
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Enable NSS output for master mode */
SPI_SSOutputCmd(SPIx, ENABLE);
/* TIM Capture Compare DMA Request enable */
TIM_DMACmd(TIMx, TIMx_DMA_CHANNEL, ENABLE);
while (1)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandReceived;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA TIM trigger channel Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandTransmitted;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(TIMx_CHANNEL_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
CommandTransmitted = 0x00;
CommandReceived = 0x00;
/* Clear the RxBuffer */
Fill_Buffer(RxBuffer, TXBUFFERSIZE);
PressedButton = Read_Joystick();
while (PressedButton == JOY_NONE)
{
PressedButton = Read_Joystick();
}
switch (PressedButton)
{
/* JOY_RIGHT button pressed */
case JOY_RIGHT:
CommandTransmitted = CMD_RIGHT;
NumberOfByte = CMD_RIGHT_SIZE;
break;
/* JOY_LEFT button pressed */
case JOY_LEFT:
CommandTransmitted = CMD_LEFT;
NumberOfByte = CMD_LEFT_SIZE;
break;
/* JOY_UP button pressed */
case JOY_UP:
CommandTransmitted = CMD_UP;
NumberOfByte = CMD_UP_SIZE;
break;
/* JOY_DOWN button pressed */
case JOY_DOWN:
CommandTransmitted = CMD_DOWN;
NumberOfByte = CMD_DOWN_SIZE;
break;
/* JOY_SEL button pressed */
case JOY_SEL:
CommandTransmitted = CMD_SEL;
NumberOfByte = CMD_SEL_SIZE;
break;
default:
break;
}
/* Enable the DMA channel */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
/* Enable DMA1 TIM Trigger Channel */
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, ENABLE);
/* TIM enable counter */
TIM_Cmd(TIMx, ENABLE);
/* Wait the SPI DMA Rx transfer complete or time out*/
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags*/
DMA_ClearFlag(TIMx_CHANNEL_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, DISABLE);
/* disable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
/* TIM disable counter */
TIM_Cmd(TIMx, DISABLE);
if (CommandReceived == CMD_ACK)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = (uint16_t)NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(TIMx_CHANNEL_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx DMA request */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
/* Enable the DMA channel */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
/* Enable DMA1 TIM Trigger Channel */
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, ENABLE);
/* TIM enable counter */
TIM_Cmd(TIMx, ENABLE);
/* Wait the SPI Rx DMA transfer complete or time out */
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(TIMx_CHANNEL_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(TIMx_CHANNEL_DMA_CHANNEL, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
/* TIM disable counter */
TIM_Cmd(TIMx, DISABLE);
switch (NumberOfByte)
{
/* CMD_RIGHT command received */
case CMD_RIGHT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received */
case CMD_LEFT_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received */
case CMD_UP_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received */
case CMD_DOWN_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received */
case CMD_SEL_SIZE:
if ((Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE, SPI_DATAMASK) != FAILED) && (CommandReceived == CMD_ACK))
{
/* Turn ON LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
}
}
#endif /* SPI_MASTER */
/* Slave board configuration -----------------------------------------------*/
#ifdef SPI_SLAVE
/* Initializes the SPI communication */
SPI_I2S_DeInit(SPIx);
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIx, &SPI_InitStructure);
/* Initialize the FIFO threshold */
SPI_RxFIFOThresholdConfig(SPIx, SPI_RxFIFOThreshold_QF);
CommandTransmitted = CMD_ACK;
/* Infinite Loop */
while (1)
{
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandReceived;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = 1;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &CommandTransmitted;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(SPIx_TX_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
CommandReceived = 0x00;
/* Enable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, ENABLE);
/* Wait the SPI DMA transfers complete or time out */
while (DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)
{}
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* Clear DMA1 global flags */
DMA_ClearFlag(SPIx_TX_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, DISABLE);
/* Disable the SPI peripheral */
SPI_Cmd(SPIx, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, DISABLE);
switch (CommandReceived)
{
/* CMD_RIGHT command received */
case CMD_RIGHT:
NumberOfByte = CMD_RIGHT_SIZE;
break;
/* CMD_LEFT command received */
case CMD_LEFT:
NumberOfByte = CMD_LEFT_SIZE;
break;
/* CMD_UP command received */
case CMD_UP:
NumberOfByte = CMD_UP_SIZE;
break;
/* CMD_DOWN command received */
case CMD_DOWN:
NumberOfByte = CMD_DOWN_SIZE;
break;
/* CMD_SEL command received */
case CMD_SEL:
NumberOfByte = CMD_SEL_SIZE;
break;
default:
break;
}
/* DMA channel Rx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)RxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_Init(SPIx_RX_DMA_CHANNEL, &DMA_InitStructure);
/* DMA channel Tx of SPI Configuration */
DMA_InitStructure.DMA_BufferSize = NumberOfByte;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)SPIx_DR_ADDRESS;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)TxBuffer;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralDST;
DMA_InitStructure.DMA_Priority = DMA_Priority_Low;
DMA_Init(SPIx_TX_DMA_CHANNEL, &DMA_InitStructure);
/* Enable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, ENABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Enable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, ENABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, ENABLE);
/* Wait the SPI DMA transfers complete or time out */
while (DMA_GetFlagStatus(SPIx_RX_DMA_FLAG_TC) == RESET)
{}
TimeOut = USER_TIMEOUT;
while ((DMA_GetFlagStatus(SPIx_TX_DMA_FLAG_TC) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
/* The BSY flag can be monitored to ensure that the SPI communication is complete.
This is required to avoid corrupting the last transmission before disabling
the SPI or entering the Stop mode. The software must first wait until TXE=1
and then until BSY=0.*/
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
TimeOut = USER_TIMEOUT;
while ((SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_BSY) == SET)&&(TimeOut != 0x00))
{}
if(TimeOut == 0)
{
TimeOut_UserCallback();
}
switch (NumberOfByte)
{
/* CMD_RIGHT command received */
case CMD_RIGHT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_RIGHT_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2 and LED3 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED4 */
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_LEFT command received */
case CMD_LEFT_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_LEFT_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED4 */
STM_EVAL_LEDOn(LED4);
/* Turn OFF LED2 and LED3 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED3);
}
break;
/* CMD_UP command received */
case CMD_UP_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_UP_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2 */
STM_EVAL_LEDOn(LED2);
/* Turn OFF LED3 and LED4 */
STM_EVAL_LEDOff(LED3);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_DOWN command received */
case CMD_DOWN_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_DOWN_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED3 */
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
break;
/* CMD_SEL command received */
case CMD_SEL_SIZE:
if (Buffercmp(TxBuffer, RxBuffer, CMD_SEL_SIZE, SPI_DATAMASK) != FAILED)
{
/* Turn ON LED2, LED3 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED3);
STM_EVAL_LEDOn(LED4);
}
break;
default:
break;
}
/* Clear DMA1 global flags */
DMA_ClearFlag(SPIx_TX_DMA_FLAG_GL);
DMA_ClearFlag(SPIx_RX_DMA_FLAG_GL);
/* Disable the DMA channels */
DMA_Cmd(SPIx_RX_DMA_CHANNEL, DISABLE);
DMA_Cmd(SPIx_TX_DMA_CHANNEL, DISABLE);
/* Disable the SPI peripheral */
SPI_Cmd(SPIx, DISABLE);
/* Disable the SPI Rx and Tx DMA requests */
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Rx, DISABLE);
SPI_I2S_DMACmd(SPIx, SPI_I2S_DMAReq_Tx, DISABLE);
}
#endif /* SPI_SLAVE */
}
/***************************************************************************************************
* @fn lcd_regist
*
* @brief LCD资源注册
* @param NULL
* @return null
***************************************************************************************************/
void lcd_regist(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//背光控制
RCC_AHB1PeriphClockCmd(LCD_BLW_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_BLW_PIN |LCD_BL_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_BLW_PORT, &GPIO_InitStructure);
//SPI口配置
RCC_AHB1PeriphClockCmd(LCD_SPI_CLK_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_SPI_CLK_PIN ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_SPI_CLK_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(LCD_SPI_CLK_PORT, LCD_SPI_CLK_PIN_SOURCE, LCD_SPI_CLK_GPIO_AF);
RCC_AHB1PeriphClockCmd(LCD_SPI_MOSI_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_SPI_MOSI_PIN ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_SPI_MOSI_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(LCD_SPI_MOSI_PORT, LCD_SPI_MOSI_PIN_SOURCE, LCD_SPI_MOSI_GPIO_AF);
RCC_AHB1PeriphClockCmd(LCD_SPI_NCS_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_SPI_NCS_PIN ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_SPI_NCS_PORT, &GPIO_InitStructure);
//GPIO_PinAFConfig(LCD_SPI_NCS_PORT, LCD_SPI_NCS_PIN_SOURCE, LCD_SPI_NCS_GPIO_AF);
//A0端口配置
RCC_AHB1PeriphClockCmd(LCD_A0_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_A0_PIN ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_A0_PORT, &GPIO_InitStructure);
//RST端口配置
RCC_AHB1PeriphClockCmd(LCD_RST_GPIO_CLK, ENABLE);
GPIO_InitStructure.GPIO_Pin = LCD_RST_PIN ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(LCD_RST_PORT, &GPIO_InitStructure);
//SPI功能配置
RCC_APB1PeriphClockCmd(LCD_SPI_MASTER_CLK, ENABLE);
/* SPI_MASTER configuration ------------------------------------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
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_16;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(LCD_SPI_MASTER, &SPI_InitStructure);
// SPI_I2S_ITConfig(LCD_SPI_MASTER,SPI_I2S_IT_TXE,DISABLE);
// SPI_I2S_ITConfig(LCD_SPI_MASTER,SPI_I2S_IT_RXNE,DISABLE);
/* Enable SPI_MASTER NSS output for master mode */
SPI_SSOutputCmd(LCD_SPI_MASTER, DISABLE);
/* Enable SPI_MASTER DMA TX */
RCC_AHB1PeriphClockCmd(LCD_DMA_CLK, ENABLE);
DMA_Cmd(LCD_DMA_STREAM, DISABLE);
DMA_DeInit(LCD_DMA_STREAM);
DMA_InitStructure.DMA_Channel = LCD_DMA_CHANNLE;
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)(&LCD_SPI_MASTER->DR);
DMA_InitStructure.DMA_Memory0BaseAddr = (uint32_t)g_lcdTxBuff;
DMA_InitStructure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
DMA_InitStructure.DMA_BufferSize = LCD_TX_BUFF_SIZE;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
DMA_InitStructure.DMA_Mode = DMA_Mode_Normal;
DMA_InitStructure.DMA_Priority = DMA_Priority_VeryHigh;
DMA_InitStructure.DMA_FIFOMode = DMA_FIFOMode_Disable;
DMA_InitStructure.DMA_FIFOThreshold = DMA_FIFOThreshold_HalfFull;
DMA_InitStructure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
DMA_InitStructure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init(LCD_DMA_STREAM, &DMA_InitStructure);
//中断控制
NVIC_InitStructure.NVIC_IRQChannel = LCD_DMA_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = LCD_DMA_NVIC_PRIORITY;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
/* Enable SPI_MASTER */
SPI_Cmd(LCD_SPI_MASTER, ENABLE);
}
int main(void)
{
/*******************GPIO configuration********************/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA,ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOA,DISABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB,ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_GPIOB,DISABLE);
/*****Master Mode*****/
GPIO_conf(GPIOA,GPIO_Pin_4,GPIO_Speed_50MHz,GPIO_Mode_AF_PP); //SPI1_NSS
GPIO_conf(GPIOA,GPIO_Pin_5,GPIO_Speed_50MHz,GPIO_Mode_AF_PP); //SPI1_SCK
GPIO_conf(GPIOA,GPIO_Pin_6,Input_Mode,GPIO_Mode_IPU); //SPI1_MISO
GPIO_conf(GPIOA,GPIO_Pin_7,GPIO_Speed_50MHz,GPIO_Mode_AF_PP); //SPI1_MOSI
/*****Slave Mode******/
GPIO_conf(GPIOB,GPIO_Pin_12,Input_Mode,GPIO_Mode_IN_FLOATING); //SPI3_NSS
GPIO_conf(GPIOB,GPIO_Pin_13,Input_Mode,GPIO_Mode_IN_FLOATING); //SPI3_SCK
GPIO_conf(GPIOB,GPIO_Pin_14,GPIO_Speed_50MHz,GPIO_Mode_AF_PP); //SPI3_MISO
GPIO_conf(GPIOB,GPIO_Pin_15,Input_Mode,GPIO_Mode_IN_FLOATING); //SPI3_MOSI
//uint32_t checkGPIOA_CRH = GPIOA->CRH;
//uint32_t checkGPIOA_CRL = GPIOA->CRL;
//uint32_t checkGPIOB_CRL = GPIOB->CRL;
/*******************SPI configuration********************/
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
RCC_APB2PeriphResetCmd(RCC_APB2Periph_SPI1,DISABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
RCC_APB1PeriphResetCmd(RCC_APB1Periph_SPI2,DISABLE);
SPI_conf(SPI1,SPI_Mode_Master,SPI_DataSize_8b,SPI_BaudRatePrescaler_4,SPI_FirstBit_LSB,idle0_1Edge);
SPI_conf(SPI2,SPI_Mode_Slave,SPI_DataSize_8b,SPI_BaudRatePrescaler_2,SPI_FirstBit_LSB,idle0_1Edge);
SPI_SSOutputCmd(SPI1,ENABLE);
enableSPI(SPI1,ENABLE);
enableSPI(SPI2,ENABLE);
// uint32_t checkSPI1_CR1 = SPI1->CR1;
// uint32_t checkSPI1_CR2 = SPI1->CR2;
// uint32_t checkSPI1_CRCPR = SPI1->CRCPR;
//uint32_t checkSPI2_CR1 = SPI2->CR1;
//uint32_t checkSPI2_CR2 = SPI2->CR2;
//uint32_t checkSPI2_CRCPR = SPI2->CRCPR;
//rxOnlyMode(SPI1,ENABLE); //If Slave Transmitted and Master Received, Rx only mode should enabled after SPE = 1.
uint16_t data1;
uint16_t data2;
while(1)
{
/*****Master Transmitted and Slave Received*****/
if( SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_TXE) ){
SPI_I2S_SendData(SPI1,'H');
}
if( SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_RXNE) ){
data1 = SPI_I2S_ReceiveData(SPI2);
}
/*****Slave Transmitted and Master Received*****/
// if( SPI_I2S_GetFlagStatus(SPI2,SPI_I2S_FLAG_TXE) ){
// SPI_I2S_SendData(SPI2,'L');
// }
// if( SPI_I2S_GetFlagStatus(SPI1,SPI_I2S_FLAG_RXNE) ){
// data2 = SPI_I2S_ReceiveData(SPI1);
// }
}
}
/**
* Initialise a single Overo device
*/
int32_t PIOS_OVERO_Init(uint32_t *overo_id, const struct pios_overo_cfg *cfg)
{
PIOS_DEBUG_Assert(overo_id);
PIOS_DEBUG_Assert(cfg);
struct pios_overo_dev *overo_dev;
overo_dev = (struct pios_overo_dev *)PIOS_OVERO_alloc();
if (!overo_dev) {
goto out_fail;
}
/* Bind the configuration to the device instance */
overo_dev->cfg = cfg;
overo_dev->writing_buffer = 1; // First writes to second buffer
/* Put buffers to a known state */
memset(&overo_dev->tx_buffer[0][0], 0xFF, PACKET_SIZE);
memset(&overo_dev->tx_buffer[1][0], 0xFF, PACKET_SIZE);
memset(&overo_dev->rx_buffer[0][0], 0xFF, PACKET_SIZE);
memset(&overo_dev->rx_buffer[1][0], 0xFF, PACKET_SIZE);
/*
* Enable the SPI device
*
* 1. Enable the SPI port
* 2. Enable DMA with circular buffered DMA (validate config)
* 3. Enable the DMA Tx IRQ
*/
// PIOS_Assert(overo_dev->cfg->dma.tx-> == CIRCULAR);
// PIOS_Assert(overo_dev->cfg->dma.rx-> == CIRCULAR);
/* only legal for single-slave config */
PIOS_Assert(overo_dev->cfg->slave_count == 1);
SPI_SSOutputCmd(overo_dev->cfg->regs, DISABLE);
/* Initialize the GPIO pins */
/* note __builtin_ctz() due to the difference between GPIO_PinX and GPIO_PinSourceX */
GPIO_PinAFConfig(overo_dev->cfg->sclk.gpio,
__builtin_ctz(overo_dev->cfg->sclk.init.GPIO_Pin),
overo_dev->cfg->remap);
GPIO_PinAFConfig(overo_dev->cfg->mosi.gpio,
__builtin_ctz(overo_dev->cfg->mosi.init.GPIO_Pin),
overo_dev->cfg->remap);
GPIO_PinAFConfig(overo_dev->cfg->miso.gpio,
__builtin_ctz(overo_dev->cfg->miso.init.GPIO_Pin),
overo_dev->cfg->remap);
GPIO_PinAFConfig(overo_dev->cfg->ssel[0].gpio,
__builtin_ctz(overo_dev->cfg->ssel[0].init.GPIO_Pin),
overo_dev->cfg->remap);
GPIO_Init(overo_dev->cfg->sclk.gpio, (GPIO_InitTypeDef *)&(overo_dev->cfg->sclk.init));
GPIO_Init(overo_dev->cfg->mosi.gpio, (GPIO_InitTypeDef *)&(overo_dev->cfg->mosi.init));
GPIO_Init(overo_dev->cfg->miso.gpio, (GPIO_InitTypeDef *)&(overo_dev->cfg->miso.init));
/* Configure circular buffer targets. Configure 0 to be initially active */
DMA_InitTypeDef dma_init;
DMA_DeInit(overo_dev->cfg->dma.rx.channel);
dma_init = overo_dev->cfg->dma.rx.init;
dma_init.DMA_Memory0BaseAddr = (uint32_t)overo_dev->rx_buffer[0];
dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
dma_init.DMA_BufferSize = PACKET_SIZE;
DMA_Init(overo_dev->cfg->dma.rx.channel, &dma_init);
DMA_DoubleBufferModeConfig(overo_dev->cfg->dma.rx.channel, (uint32_t)overo_dev->rx_buffer[1], DMA_Memory_0);
DMA_DoubleBufferModeCmd(overo_dev->cfg->dma.rx.channel, ENABLE);
DMA_DeInit(overo_dev->cfg->dma.tx.channel);
dma_init = overo_dev->cfg->dma.tx.init;
dma_init.DMA_Memory0BaseAddr = (uint32_t)overo_dev->tx_buffer[0];
dma_init.DMA_MemoryInc = DMA_MemoryInc_Enable;
dma_init.DMA_BufferSize = PACKET_SIZE;
DMA_Init(overo_dev->cfg->dma.tx.channel, &dma_init);
DMA_DoubleBufferModeConfig(overo_dev->cfg->dma.tx.channel, (uint32_t)overo_dev->tx_buffer[1], DMA_Memory_0);
DMA_DoubleBufferModeCmd(overo_dev->cfg->dma.tx.channel, ENABLE);
/* Set the packet size */
DMA_SetCurrDataCounter(overo_dev->cfg->dma.rx.channel, PACKET_SIZE);
DMA_SetCurrDataCounter(overo_dev->cfg->dma.tx.channel, PACKET_SIZE);
/* Initialize the SPI block */
SPI_DeInit(overo_dev->cfg->regs);
SPI_Init(overo_dev->cfg->regs, (SPI_InitTypeDef *)&(overo_dev->cfg->init));
SPI_CalculateCRC(overo_dev->cfg->regs, DISABLE);
/* Enable SPI */
SPI_Cmd(overo_dev->cfg->regs, ENABLE);
/* Enable SPI interrupts to DMA */
SPI_I2S_DMACmd(overo_dev->cfg->regs, SPI_I2S_DMAReq_Tx | SPI_I2S_DMAReq_Rx, ENABLE);
/* Configure DMA interrupt */
NVIC_Init((NVIC_InitTypeDef *)&(overo_dev->cfg->dma.irq.init));
DMA_ITConfig(overo_dev->cfg->dma.tx.channel, DMA_IT_TC, ENABLE);
/* Enable the DMA channels */
DMA_Cmd(overo_dev->cfg->dma.tx.channel, ENABLE);
DMA_Cmd(overo_dev->cfg->dma.rx.channel, ENABLE);
*overo_id = (uint32_t)overo_dev;
return 0;
out_fail:
return -1;
}
void LMP_SPI_Init(void)
{
SPI_InitTypeDef SPI2_InitStruct;
SPI_InitTypeDef SPI3_InitStruct;
GPIO_InitTypeDef GPIOB_InitStruct;
/*Clock enabling*/
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
/* Enable the SPI clock */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
/* Enable GPIO clocks */
RCC_AHB1PeriphClockCmd(SPI2_SCK_GPIO_CLK | SPI2_MOSI_GPIO_CLK | SPI2_MISO_GPIO_CLK | SPI2_SS_GPIO_CLK , ENABLE);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
//GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
//GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
/* SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = SPI2_SCK_PIN;
GPIO_Init(SPI2_SCK_GPIO_PORT, &GPIO_InitStructure);
/* Connect SPI pins to AF5 */
GPIO_PinAFConfig(SPI2_SCK_GPIO_PORT, SPI2_SCK_SOURCE, SPI2_SCK_AF);
/* SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = SPI2_MOSI_PIN;
GPIO_Init(SPI2_MOSI_GPIO_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(SPI2_MOSI_GPIO_PORT, SPI2_MOSI_SOURCE, SPI2_MOSI_AF);
/* SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = SPI2_MISO_PIN;
GPIO_Init(SPI2_MISO_GPIO_PORT, &GPIO_InitStructure);
GPIO_PinAFConfig(SPI2_MOSI_GPIO_PORT, SPI2_MOSI_SOURCE, SPI2_MOSI_AF);
//Error 120813
/* SPI SS and SS2 pin configuration */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Pin = SPI2_SS_PIN | SPI2_SS2_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_SetBits(SPI2_SS_GPIO_PORT , SPI2_SS_PIN);
GPIO_SetBits(SPI2_SS2_GPIO_PORT , SPI2_SS2_PIN);
GPIO_Init(SPI2_SS_GPIO_PORT, &GPIO_InitStructure);
SPI_StructInit(&SPI2_InitStruct);
/* SPI SS3 and SS4 pin configuration */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_Pin = SPI2_SS3_PIN | SPI2_SS4_PIN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_SetBits(SPI2_SS3_GPIO_PORT , SPI2_SS3_PIN);
GPIO_SetBits(SPI2_SS4_GPIO_PORT , SPI2_SS4_PIN);
GPIO_Init(SPI2_SS3_GPIO_PORT, &GPIO_InitStructure);
SPI_StructInit(&SPI2_InitStruct);
//SPI2_InitStruct.SPI_Direction = SPI_Direction_1Line_Tx;
SPI2_InitStruct.SPI_DataSize = SPI_DataSize_16b;
SPI2_InitStruct.SPI_Mode = SPI_Mode_Master;
SPI2_InitStruct.SPI_NSS = SPI_NSS_Soft;
SPI2_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
SPI_Init(SPI2, &SPI2_InitStruct);
//SPI_Cmd(SPI2, ENABLE);
SPI_SSOutputCmd(SPI2, ENABLE);
}
/*************************************************
Function: hw_wireless_init
Description:
Input:
Output:
Return:
Others:
*************************************************/
void hw_wireless_init(void)
{
/* PCLK2 = HCLK/2 */
RCC_PCLK2Config(RCC_HCLK_Div2);
/* Enable SPI clock and GPIO clock for SPI */
RCC_APB2PeriphClockCmd(WIRELESS_SPI_GPIO_CLK|WIRELESS_SPI_IRQ_CLK, ENABLE);
/* Enable SPI_SLAVE Periph clock */
RCC_APB1PeriphClockCmd(WIRELESS_SPI_CLK, ENABLE);
/* Configure SPI pins: NSS, SCK and MOSI */
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = WIRELESS_SPI_PIN_SCK | WIRELESS_SPI_PIN_MOSI;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(WIRELESS_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = WIRELESS_SPI_PIN_NSS|WIRELESS_SPI_PIN_CE;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(WIRELESS_SPI_GPIO, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = WIRELESS_SPI_PIN_MISO;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(WIRELESS_SPI_GPIO, &GPIO_InitStructure);
/* Configure PA.00 pin as input floating */
GPIO_InitStructure.GPIO_Pin = WIRELESS_SPI_PIN_IRQ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(WIRELESS_SPI_IRQ_GPIO, &GPIO_InitStructure);
/* Enable AFIO clock */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
/* Connect EXTI0 Line to PA.00 pin */
GPIO_EXTILineConfig(WIRELESS_SPI_IRQ_RES, WIRELESS_SPI_GPIO_RES);
/* Configure EXTI0 line */
EXTI_InitTypeDef EXTI_InitStructure;
EXTI_InitStructure.EXTI_Line = WIRELESS_SPI_EXTI;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
/* Enable and set EXTI0 Interrupt to the lowest priority */
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
NVIC_InitStructure.NVIC_IRQChannel = WIRELESS_SPI_RX_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
EXTI_ClearFlag(WIRELESS_SPI_EXTI);
/* Spi Init*/
SPI_InitTypeDef SPI_InitStructure;
SPI_Cmd(WIRELESS_SPI, DISABLE);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(WIRELESS_SPI, &SPI_InitStructure);
SPI_SSOutputCmd(WIRELESS_SPI, ENABLE);
SPI_Cmd(WIRELESS_SPI, ENABLE);
uint16_t TX_ADDRESS[5];
RF_SET_DEFAULT_ADDR(TX_ADDRESS);
hw_wireless_init_mode();
hw_wireless_set_tx_addr(TX_ADDRESS, 5);
hw_wireless_set_rx_addr(0, TX_ADDRESS, 5);
hw_wireless_rx_mode();
int i;
hw_serial_printf("**************************************************\n");
for (i = 0; i < (RF_FIFO_STATUS+1); i++)
{
hw_wireless_printf(i);
}
hw_serial_printf("**************************************************\n");
}
void init_spi (void) {
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
EXTI_InitTypeDef EXTI_InitStructure;
RCC_APB2PeriphClockCmd(
RCC_APB2Periph_GPIOA |
RCC_APB2Periph_AFIO |
RCC_APB2Periph_SPI1,
ENABLE
);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7 | GPIO_Pin_6 | GPIO_Pin_5;
GPIO_Init(GPIOA, &GPIO_InitStructure);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPI1, &SPI_InitStructure);
SPI_SSOutputCmd(SPI1, ENABLE);
SPI_Cmd(SPI1, ENABLE);
/* Connect EXTI Line13 to PA6 - MISO I pin */
GPIO_EXTILineConfig(GPIO_PortSourceGPIOA,GPIO_PinSource6);
EXTI_InitStructure.EXTI_Line = EXTI_Line6;
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
EXTI_InitStructure.EXTI_LineCmd = ENABLE;
EXTI_Init(&EXTI_InitStructure);
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);
NVIC_InitStructure.NVIC_IRQChannel = EXTI9_5_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0x00;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0x00;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
raise_css();
rf_reset();
configure();
//send_strobe (TI_CCxxx0_SFSTXON);
//send_strobe (TI_CCxxx0_SRX);
//rf_send_byte (0x13);
//test_send();
// SPI_I2S_SendData(SPI1, TI_CCxxx0_SRES);
}
void initial_spi(void) {
GPIO_InitTypeDef structGPIO;
SPI_InitTypeDef structSPI;
//NVIC_InitTypeDef NVIC_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI3, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC | RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOF, ENABLE);
//configure GPIO
structGPIO.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_7; //spi1
structGPIO.GPIO_Mode = GPIO_Mode_AF;
structGPIO.GPIO_Speed = GPIO_Speed_50MHz;
structGPIO.GPIO_OType = GPIO_OType_PP;
structGPIO.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOA, &structGPIO);
structGPIO.GPIO_Pin = GPIO_Pin_4;
GPIO_Init(GPIOB, &structGPIO);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource4, GPIO_AF_5);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_5);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource4, GPIO_AF_5);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_5);
structGPIO.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11 | GPIO_Pin_12; //spi3
structGPIO.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &structGPIO);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_6);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_6);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource12, GPIO_AF_6);
structGPIO.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOA, &structGPIO);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource15, GPIO_AF_6);
structGPIO.GPIO_Pin = GPIO_Pin_14 | GPIO_Pin_15; //spi2
structGPIO.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOB, &structGPIO);
structGPIO.GPIO_Pin = GPIO_Pin_9;
GPIO_Init(GPIOF, &structGPIO);
structGPIO.GPIO_Pin = GPIO_Pin_15;
structGPIO.GPIO_Mode = GPIO_Mode_OUT;
structGPIO.GPIO_OType = GPIO_OType_PP;
structGPIO.GPIO_PuPd = GPIO_PuPd_UP;
structGPIO.GPIO_Speed = GPIO_Speed_2MHz;
GPIO_Init(GPIOD, &structGPIO);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_5);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_5);
GPIO_PinAFConfig(GPIOF, GPIO_PinSource9, GPIO_AF_5);
//configure spi1 and spi3
SPI_StructInit(&structSPI);
structSPI.SPI_Direction = SPI_Direction_1Line_Tx;
structSPI.SPI_Mode = SPI_Mode_Master;
structSPI.SPI_DataSize = SPI_DataSize_16b;
structSPI.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4/*SPI_BaudRatePrescaler_32*/;
structSPI.SPI_NSS = SPI_NSS_Hard;
structSPI.SPI_CPOL = SPI_CPOL_Low;
structSPI.SPI_CPHA = SPI_CPHA_1Edge;
SPI_Init(SPI1, &structSPI);
structSPI.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2 /*SPI_BaudRatePrescaler_32*/;
SPI_Init(SPI3, &structSPI);
SPI_SSOutputCmd(SPI1, ENABLE);
SPI_SSOutputCmd(SPI3, ENABLE);
SPI_Cmd(SPI1, ENABLE);
SPI_Cmd(SPI3, ENABLE);
//configure spi2
GPIO_WriteBit(GPIOD, GPIO_Pin_15, Bit_SET);
structSPI.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
structSPI.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_Init(SPI2, &structSPI);
SPI_SSOutputCmd(SPI2, ENABLE);
SPI_NSSPulseModeCmd(SPI2, DISABLE);
SPI_Cmd(SPI2, ENABLE);
return;
}
void init_SPI2(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
SPI_InitTypeDef SPI_InitStruct;
// enable clock for used IO pins
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
/* Configure pins used by SPI2
* PB10 = SCK
* PC2 = MISO
* PC3 = MOSI
* PB14 = NSS
*
*/
// PORT B SCK
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_10;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOB, &GPIO_InitStruct);
// PORT C MISO and MOSI
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_2 | GPIO_Pin_3;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_Init(GPIOC, &GPIO_InitStruct);
// PORT B NSS
GPIO_InitStruct.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(GPIOB, &GPIO_InitStruct);
// connect SPI1 pins to SPI alternate function
GPIO_PinAFConfig(GPIOB, GPIO_PinSource10, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource2, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOC, GPIO_PinSource3, GPIO_AF_SPI2);
GPIO_setBits(GPIOB, GPIO_Pin_14); // set PB14 high
// enable peripheral clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
/* configure SPI1 in Mode 0
* CPOL = 1 --> clock is high when idle
* CPHA = 0 --> data is sampled at the first edge
*/
//SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // set to full duplex mode, seperate MOSI and MISO lines
SPI_InitStruct.SPI_Direction = SPI_Direction_1Line_Rx;
SPI_InitStruct.SPI_Mode = SPI_Mode_Master; // transmit in master mode, NSS pin has to be always high
SPI_InitStruct.SPI_DataSize = SPI_DataSize_16b; // one packet of data is 16 bits wide
SPI_InitStruct.SPI_CPOL = SPI_CPOL_High; // clock is high when idle
SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge; // data sampled at first edge
//SPI_InitStruct.SPI_NSS = SPI_NSS_Soft | SPI_NSSInternalSoft_Set; // set the NSS management to internal and pull internal NSS high
SPI_InitStruct.SPI_NSS = SPI_NSS_Hard;
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256; // SPI frequency is APB1 frequency / 256
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB;// data is transmitted MSB first
SPI_Init(SPI2, &SPI_InitStruct);
SPI_SSOutputCmd(SPI2, ENABLE);
SPI_Cmd(SPI2, ENABLE); // enable SPI2
}
void SPIX_Init(uint8_t SPI_NO)
{
// GPIO initial
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
if (SPI_NO == SPIX_1)
{
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC|RCC_APB2Periph_SPI1, ENABLE ); // Turn on SPI clock and GPIOA clock.
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7; //PA5:SCK, PA6:MISO, PA7:MOSI
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA,GPIO_Pin_5|GPIO_Pin_7); // Pull high.
}
else if (SPI_NO == SPIX_2)
{
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
RCC_APB1PeriphClockCmd( RCC_APB1Periph_SPI2, ENABLE );
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15; //PB13:SCK, PB14:MISO, PB15:MOSI
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_15); // Pull high.
}
// SPI function initial.
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; // Data size 8 bits.
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High; // Normal clock is high.
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; // NSS self control.
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7; //set, but not use.
//===========================================================================
// SPI CRC using note:
///* Enable SPI CRC calculation */
// SPI_CalculateCRC(SPI, ENABLE); <-- in setting.
//
// During send loop:
// /* Send last SPI2_Buffer_Tx data */
// SPI_I2S_SendData(SPI2, SPI2_Buffer_Tx[TxIdx]);
// /* Enable SPI2 CRC transmission */
// SPI_TransmitCRC(SPI2);
// ref link: https://github.com/david2004kang/gcc-arm-none-eabi_samples/blob/master/STM32F10x_StdPeriph_Lib_V3.5.0/Project/STM32F10x_StdPeriph_Examples/SPI/CRC/main.c
if (SPI_NO == SPIX_1 && !u8SPI1_Inital)
{
SPI_Init(SPI1, &SPI_InitStructure);
SPI_SSOutputCmd(SPI1, ENABLE);// Configure?PA.4(NSS) ,but we need use it as GPIO
SPI_Cmd(SPI1, ENABLE);
//=============================================================
// SET UP other ext pins.
// PA3:LCD reset, , 0 = reset, normal 1
// PA4:NSS, Enable = 0, Disable = 1
// PA8:D/C data = 1, command = 0
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_8; // Self control NSS, DC, RST
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_SetBits(GPIOA, GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_8); // Pull high.
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4; // NRF24L01 CSN
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
GPIO_SetBits(GPIOC, GPIO_Pin_4); // Pull high.
INIT_RINGBUFFER(SPI1_TXCmdBuffer);
INIT_RINGBUFFER(SPI1_RXBuffer);
u8Nss1Low = 0;
u8SPI1_Inital = 1;
}
else if (SPI_NO == SPIX_2 && !u8SPI2_Inital)
{
SPI_Init(SPI2, &SPI_InitStructure);
SPI_SSOutputCmd(SPI2, ENABLE);// Configure?PA.4(NSS) ,but we need use it as GPIO
SPI_Cmd(SPI2, ENABLE);
//=============================================================
// SET UP other ext pins.
// PB11:LCD reset, , 0 = reset, normal 1
// PB12:NSS, Enable = 0, Disable = 1
// PB10:D/C data = 1, command = 0
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12; // Self control NSS, DC, RST
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOB, &GPIO_InitStructure);
GPIO_SetBits(GPIOB, GPIO_Pin_10|GPIO_Pin_11|GPIO_Pin_12); // Pull high.
INIT_RINGBUFFER(SPI2_TXCmdBuffer);
INIT_RINGBUFFER(SPI2_RXBuffer);
u8Nss2Low = 0;
u8SPI2_Inital = 1;
}
printf("NokiaLCD5110Init() create thread OK.\r\n");
}