platform_result_t platform_spi_init( const platform_spi_t* spi, const platform_spi_config_t* config )
{
SPI_InitTypeDef spi_init;
platform_result_t result;
uint8_t spi_number;
wiced_assert( "bad argument", ( spi != NULL ) && ( config != NULL ) );
platform_mcu_powersave_disable();
spi_number = platform_spi_get_port_number( spi->port );
/* Init SPI GPIOs */
platform_gpio_set_alternate_function( spi->pin_clock->port, spi->pin_clock->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, spi->gpio_af );
platform_gpio_set_alternate_function( spi->pin_mosi->port, spi->pin_mosi->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, spi->gpio_af );
platform_gpio_set_alternate_function( spi->pin_miso->port, spi->pin_miso->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, spi->gpio_af );
/* Init the chip select GPIO */
platform_gpio_init( config->chip_select, OUTPUT_PUSH_PULL );
platform_gpio_output_high( config->chip_select );
/* Calculate prescaler */
result = calculate_prescaler( config->speed, &spi_init.SPI_BaudRatePrescaler );
if ( result != PLATFORM_SUCCESS )
{
platform_mcu_powersave_enable();
return result;
}
/* Configure data-width */
if ( config->bits == 8 )
{
spi_init.SPI_DataSize = SPI_DataSize_8b;
}
else if ( config->bits == 16 )
{
if ( config->mode & SPI_USE_DMA )
{
platform_mcu_powersave_enable();
/* 16 bit mode is not supported for a DMA */
return PLATFORM_UNSUPPORTED;
}
spi_init.SPI_DataSize = SPI_DataSize_16b;
}
else
{
platform_mcu_powersave_enable();
/* Requested mode is not supported */
return PLATFORM_UNSUPPORTED;
}
/* Configure MSB or LSB */
if ( config->mode & SPI_MSB_FIRST )
{
spi_init.SPI_FirstBit = SPI_FirstBit_MSB;
}
else
{
spi_init.SPI_FirstBit = SPI_FirstBit_LSB;
}
/* Configure mode CPHA and CPOL */
if ( config->mode & SPI_CLOCK_IDLE_HIGH )
{
spi_init.SPI_CPOL = SPI_CPOL_High;
}
else
{
spi_init.SPI_CPOL = SPI_CPOL_Low;
}
if ( config->mode & SPI_CLOCK_RISING_EDGE )
{
spi_init.SPI_CPHA = ( config->mode & SPI_CLOCK_IDLE_HIGH ) ? SPI_CPHA_2Edge : SPI_CPHA_1Edge;
}
else
{
spi_init.SPI_CPHA = ( config->mode & SPI_CLOCK_IDLE_HIGH ) ? SPI_CPHA_1Edge : SPI_CPHA_2Edge;
}
/* Enable SPI peripheral clock */
spi_peripheral_clock_functions[ spi_number ]( spi_peripheral_clocks[ spi_number ], ENABLE );
spi_init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi_init.SPI_Mode = SPI_Mode_Master;
spi_init.SPI_NSS = SPI_NSS_Soft;
spi_init.SPI_CRCPolynomial = 0x7; /* reset value */
SPI_CalculateCRC( spi->port, DISABLE );
/* Init and enable SPI */
SPI_Init( spi->port, &spi_init );
SPI_Cmd ( spi->port, ENABLE );
platform_mcu_powersave_enable();
return PLATFORM_SUCCESS;
}
DRV_Spi_Error DRV_Spi_Open( const char *pcName , DRV_Spi_Handle *pHandle)
{
DRV_Spi_Error eError = Spi_Device_Not_Found;
int iSpiIndex;
Spi_Device_Data *pSpiData;
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
volatile unsigned char ucDummyread;
for ( iSpiIndex = 0 ; iSpiIndex < SPI_DEVICE_COUNT ; iSpiIndex++ )
{
if( !strcmp( pcName , SPI_DeviceDataList[iSpiIndex].pCfg->pcName) )
{
pSpiData = &SPI_DeviceDataList[iSpiIndex];
eError=Spi_No_Error;
break;
}
}
if( eError==Spi_Device_Not_Found )
return eError;
if( pSpiData->eState == Spi_Device_Open)
return Spi_AlreadyOpened;
*pHandle =(DRV_Spi_Handle) pSpiData;
/* Enable SPI clock */
pSpiData->pCfg->PeriphClock.Cmd(pSpiData->pCfg->PeriphClock.Clock,ENABLE);
/* Enable SPI_SLAVE DMA clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 , ENABLE);
/* Configure SPI pins: SCK and MOSI with default alternate function (not remapped) push-pull */
GPIO_InitStructure.GPIO_Pin = pSpiData->pCfg->PIO.SCK_Pin | pSpiData->pCfg->PIO.MOSI_Pin;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_Init(pSpiData->pCfg->PIO.PORT, &GPIO_InitStructure);
/* Configure MISO as Input with internal pull-up */
GPIO_InitStructure.GPIO_Pin = pSpiData->pCfg->PIO.MISO_Pin;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
//GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_Init(pSpiData->pCfg->PIO.PORT, &GPIO_InitStructure);
/* SPI 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_Low;
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = pSpiData->pCfg->speed[DRV_SPI_SLOW];
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(pSpiData->pCfg->pDevice, &SPI_InitStructure);
SPI_CalculateCRC(pSpiData->pCfg->pDevice, DISABLE);
SPI_Cmd(pSpiData->pCfg->pDevice, ENABLE);
/* drain SPI */
while (SPI_I2S_GetFlagStatus(pSpiData->pCfg->pDevice, SPI_I2S_FLAG_TXE) == RESET)
;
ucDummyread = SPI_I2S_ReceiveData(pSpiData->pCfg->pDevice);
/* Set device unlock */
pSpiData->ucLock=0;
return eError;
}
/**
* Initialize SPI Peripheral Device.
* @param spi SPI index number (@ref wizpf_spi)
* @return RET_OK: Success
* @return RET_NOK: Error
*/
int8 wizpf_spi_init(wizpf_spi spi)
{
SPI_TypeDef *SPIx;
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
switch(spi) {
case WIZ_SPI1:
#if defined(SPI1_SCS_PIN) && defined(SPI1_SCLK_PIN) && defined(SPI1_MISO_PIN) && defined(SPI1_MOSI_PIN)
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = SPI1_SCS_PIN;
GPIO_Init(SPI1_SCS_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = SPI1_SCLK_PIN;
GPIO_Init(SPI1_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI1_MISO_PIN;
GPIO_Init(SPI1_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI1_MOSI_PIN;
GPIO_Init(SPI1_MOSI_PORT, &GPIO_InitStructure);
GPIO_SetBits(SPI1_SCS_PORT, SPI1_SCS_PIN);
SPIx = SPI1;
break;
#else
LOG("Not implemented");
return RET_NOK;
#endif
case WIZ_SPI2:
#if defined(SPI2_SCS_PIN) && defined(SPI2_SCLK_PIN) && defined(SPI2_MISO_PIN) && defined(SPI2_MOSI_PIN)
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Pin = SPI2_SCS_PIN;
GPIO_Init(SPI2_SCS_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Pin = SPI2_SCLK_PIN;
GPIO_Init(SPI2_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI2_MISO_PIN;
GPIO_Init(SPI2_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = SPI2_MOSI_PIN;
GPIO_Init(SPI2_MOSI_PORT, &GPIO_InitStructure);
GPIO_SetBits(SPI2_SCS_PORT, SPI2_SCS_PIN);
SPIx = SPI2;
break;
#else
LOG("Not implemented");
return RET_NOK;
#endif
//case WIZ_SPI3:
// break;
default:
ERRA("SPI(%d) is not allowed", spi);
return RET_NOK;
}
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_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPIx, &SPI_InitStructure);
SPI_Cmd(SPIx, ENABLE);
return RET_OK;
}
static rt_err_t configure(struct rt_spi_device* device,
struct rt_spi_configuration* configuration)
{
struct stm32_spi_bus * stm32_spi_bus = (struct stm32_spi_bus *)device->bus;
SPI_InitTypeDef SPI_InitStructure;
SPI_StructInit(&SPI_InitStructure);
/* data_width */
if(configuration->data_width <= 8)
{
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
}
else if(configuration->data_width <= 16)
{
SPI_InitStructure.SPI_DataSize = SPI_DataSize_16b;
}
else
{
return RT_EIO;
}
/* baudrate */
{
uint32_t SPI_APB_CLOCK;
uint32_t stm32_spi_max_clock;
uint32_t max_hz;
stm32_spi_max_clock = 18000000;
max_hz = configuration->max_hz;
#ifdef STM32F4XX
stm32_spi_max_clock = 37500000;
#elif STM32F2XX
stm32_spi_max_clock = 30000000;
#endif
if(max_hz > stm32_spi_max_clock)
{
max_hz = stm32_spi_max_clock;
}
SPI_APB_CLOCK = SystemCoreClock / 4;
/* STM32F2xx SPI MAX 30Mhz */
/* STM32F4xx SPI MAX 37.5Mhz */
if(max_hz >= SPI_APB_CLOCK/2 && SPI_APB_CLOCK/2 <= 30000000)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
}
else if(max_hz >= SPI_APB_CLOCK/4)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
}
else if(max_hz >= SPI_APB_CLOCK/8)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
}
else if(max_hz >= SPI_APB_CLOCK/16)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;
}
else if(max_hz >= SPI_APB_CLOCK/32)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32;
}
else if(max_hz >= SPI_APB_CLOCK/64)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
}
else if(max_hz >= SPI_APB_CLOCK/128)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_128;
}
else
{
/* min prescaler 256 */
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;
}
} /* baudrate */
/* CPOL */
if(configuration->mode & RT_SPI_CPOL)
{
SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;
}
else
{
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
}
/* CPHA */
if(configuration->mode & RT_SPI_CPHA)
{
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;
}
else
{
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
}
/* MSB or LSB */
if(configuration->mode & RT_SPI_MSB)
{
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
}
else
{
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_LSB;
}
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
/* init SPI */
SPI_I2S_DeInit(stm32_spi_bus->SPI);
SPI_Init(stm32_spi_bus->SPI, &SPI_InitStructure);
/* Enable SPI_MASTER */
SPI_Cmd(stm32_spi_bus->SPI, ENABLE);
SPI_CalculateCRC(stm32_spi_bus->SPI, DISABLE);
return RT_EOK;
};
OSStatus platform_spi_init( platform_spi_driver_t* driver, const platform_spi_t* peripheral, const platform_spi_config_t* config )
{
SPI_InitTypeDef spi_init;
OSStatus err;
platform_mcu_powersave_disable();
require_action_quiet( ( driver != NULL ) && ( peripheral != NULL ) && ( config != NULL ), exit, err = kParamErr);
/* Calculate prescaler */
err = calculate_prescaler( config->speed, &spi_init.SPI_BaudRatePrescaler );
require_noerr(err, exit);
/* Configure data-width */
if ( config->bits == 8 )
{
spi_init.SPI_DataSize = SPI_DataSize_8b;
}
else if ( config->bits == 16 )
{
require_action( !(config->mode & SPI_USE_DMA), exit, err = kUnsupportedErr);
spi_init.SPI_DataSize = SPI_DataSize_16b;
}
else
{
err = kUnsupportedErr;
goto exit;
}
/* Configure MSB or LSB */
if ( config->mode & SPI_MSB_FIRST )
{
spi_init.SPI_FirstBit = SPI_FirstBit_MSB;
}
else
{
spi_init.SPI_FirstBit = SPI_FirstBit_LSB;
}
/* Configure mode CPHA and CPOL */
if ( config->mode & SPI_CLOCK_IDLE_HIGH )
{
spi_init.SPI_CPOL = SPI_CPOL_High;
}
else
{
spi_init.SPI_CPOL = SPI_CPOL_Low;
}
if ( config->mode & SPI_CLOCK_RISING_EDGE )
{
spi_init.SPI_CPHA = ( config->mode & SPI_CLOCK_IDLE_HIGH ) ? SPI_CPHA_2Edge : SPI_CPHA_1Edge;
}
else
{
spi_init.SPI_CPHA = ( config->mode & SPI_CLOCK_IDLE_HIGH ) ? SPI_CPHA_1Edge : SPI_CPHA_2Edge;
}
driver->peripheral = (platform_spi_t *)peripheral;
/* Init SPI GPIOs */
platform_gpio_set_alternate_function( peripheral->pin_clock->port, peripheral->pin_clock->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, peripheral->gpio_af );
platform_gpio_set_alternate_function( peripheral->pin_mosi->port, peripheral->pin_mosi->pin_number, GPIO_OType_PP, GPIO_PuPd_NOPULL, peripheral->gpio_af );
platform_gpio_set_alternate_function( peripheral->pin_miso->port, peripheral->pin_miso->pin_number, GPIO_OType_PP, GPIO_PuPd_UP, peripheral->gpio_af );
/* Init the chip select GPIO */
platform_gpio_init( config->chip_select, OUTPUT_PUSH_PULL );
platform_gpio_output_high( config->chip_select );
/* Enable SPI peripheral clock */
(peripheral->peripheral_clock_func)( peripheral->peripheral_clock_reg, ENABLE );
(peripheral->peripheral_clock_func)( peripheral->peripheral_clock_reg, ENABLE );
SPI_I2S_DeInit( peripheral->port );
spi_init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi_init.SPI_Mode = SPI_Mode_Master;
spi_init.SPI_NSS = SPI_NSS_Soft;
spi_init.SPI_CRCPolynomial = 0x7; /* reset value */
SPI_CalculateCRC( peripheral->port, DISABLE );
/* Init and enable SPI */
SPI_Init( peripheral->port, &spi_init );
SPI_I2S_DMACmd( peripheral->port, SPI_I2S_DMAReq_Rx, DISABLE );
SPI_I2S_DMACmd( peripheral->port, SPI_I2S_DMAReq_Tx, DISABLE );
SPI_Cmd ( peripheral->port, ENABLE );
if ( config->mode & SPI_USE_DMA ){
DMA_DeInit( peripheral->rx_dma.stream );
DMA_DeInit( peripheral->tx_dma.stream );
if ( peripheral->tx_dma.controller == DMA1 )
{
RCC->AHB1ENR |= RCC_AHB1Periph_DMA1;
}
else
{
RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;
}
if ( peripheral->rx_dma.controller == DMA1 )
{
RCC->AHB1ENR |= RCC_AHB1Periph_DMA1;
}
else
{
RCC->AHB1ENR |= RCC_AHB1Periph_DMA2;
}
SPI_I2S_DMACmd( peripheral->port, SPI_I2S_DMAReq_Rx, ENABLE );
SPI_I2S_DMACmd( peripheral->port, SPI_I2S_DMAReq_Tx, ENABLE );
}
exit:
platform_mcu_powersave_enable();
return err;
}
/**
* @brief Initializes the low level interface used to drive the LIS302DL
* @param None
* @retval None
*/
static void LIS302DL_LowLevel_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Enable the SPI periph */
RCC_APB2PeriphClockCmd(LIS302DL_SPI_CLK, ENABLE);
/* Enable SCK, MOSI and MISO GPIO clocks */
RCC_AHB1PeriphClockCmd(LIS302DL_SPI_SCK_GPIO_CLK | LIS302DL_SPI_MISO_GPIO_CLK | LIS302DL_SPI_MOSI_GPIO_CLK, ENABLE);
/* Enable CS GPIO clock */
RCC_AHB1PeriphClockCmd(LIS302DL_SPI_CS_GPIO_CLK, ENABLE);
/* Enable INT1 GPIO clock */
RCC_AHB1PeriphClockCmd(LIS302DL_SPI_INT1_GPIO_CLK, ENABLE);
/* Enable INT2 GPIO clock */
RCC_AHB1PeriphClockCmd(LIS302DL_SPI_INT2_GPIO_CLK, ENABLE);
GPIO_PinAFConfig(LIS302DL_SPI_SCK_GPIO_PORT, LIS302DL_SPI_SCK_SOURCE, LIS302DL_SPI_SCK_AF);
GPIO_PinAFConfig(LIS302DL_SPI_MISO_GPIO_PORT, LIS302DL_SPI_MISO_SOURCE, LIS302DL_SPI_MISO_AF);
GPIO_PinAFConfig(LIS302DL_SPI_MOSI_GPIO_PORT, LIS302DL_SPI_MOSI_SOURCE, LIS302DL_SPI_MOSI_AF);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/* SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_SCK_PIN;
GPIO_Init(LIS302DL_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
/* SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_MOSI_PIN;
GPIO_Init(LIS302DL_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
/* SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_MISO_PIN;
GPIO_Init(LIS302DL_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
/* SPI configuration -------------------------------------------------------*/
SPI_I2S_DeInit(LIS302DL_SPI);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(LIS302DL_SPI, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(LIS302DL_SPI, ENABLE);
/* Configure GPIO PIN for Lis Chip select */
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_CS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(LIS302DL_SPI_CS_GPIO_PORT, &GPIO_InitStructure);
/* Deselect : Chip Select high */
GPIO_SetBits(LIS302DL_SPI_CS_GPIO_PORT, LIS302DL_SPI_CS_PIN);
/* Configure GPIO PINs to detect Interrupts */
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_INT1_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(LIS302DL_SPI_INT1_GPIO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = LIS302DL_SPI_INT2_PIN;
GPIO_Init(LIS302DL_SPI_INT2_GPIO_PORT, &GPIO_InitStructure);
}
int spi_init(SPI_TypeDef* SPIx) {
GPIO_InitTypeDef GPIO_InitStructure;
RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE); // USART use DMA1 -> RM0008 Table 78
if (SPIx == SPI1) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
GPIO_StructInit(&GPIO_InitStructure);
// SPI1_NCC Pin PA4
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// SPI1_SCK Pin PA5
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// SPI1_MISO Pin PA6
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // Input pull-up
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
// SPI1_MOSI Pin PA7
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
} else if (SPIx == SPI2) {
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
GPIO_StructInit(&GPIO_InitStructure);
// SPI2_NCC Pin PB12
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// SPI2_SCK Pin PB13
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// SPI2_MISO Pin PB14
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; // Input pull-up
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
// SPI2_MOSI Pin PB15
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
}
SPI_InitTypeDef SPI_InitStructure;
SPI_StructInit(&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_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_64;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SPIx, &SPI_InitStructure);
SPI_Cmd(SPIx, ENABLE);
}
/**
* @brief Initializes the SPI for the EEPROM.
* SPI, MISO, MOSI and SCLK are the same used for the SPIRIT1.
* This function can be replaced by EepromCsPinInitialization if
* SpiritSpiInit is called.
* @param None
* @retval None
*/
void EepromSpiInitialization(void)
{
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
s_EepromSpiPort = s_EepromSpiPortVersion[SdkEvalGetVersion()];
s_vectnEepromSpiCsPin = (uint16_t *)&s_vectpxEepromSpiCsPinVersion[SdkEvalGetVersion()];
s_vectpxEepromSpiCsPort = &s_vectpxEepromSpiCsPortVersion[SdkEvalGetVersion()];
if(SdkEvalGetVersion() == SDK_EVAL_VERSION_2_1) {
/* Enable SPI periph and SCLK, MOSI, MISO and CS GPIO clocks */
RCC_APB2PeriphClockCmd(EEPROM_V2_SPI_PERIPH_RCC, ENABLE);
RCC_AHBPeriphClockCmd(EEPROM_V2_SPI_PERIPH_MOSI_RCC | EEPROM_V2_SPI_PERIPH_MISO_RCC | EEPROM_V2_SPI_PERIPH_SCLK_RCC | EEPROM_V2_SPI_PERIPH_CS_RCC, ENABLE);
/* Configure the AF for MOSI, MISO and SCLK GPIO pins*/
GPIO_PinAFConfig(EEPROM_V2_SPI_PERIPH_MOSI_PORT, EEPROM_V2_SPI_PERIPH_MOSI_RCC_SOURCE, EEPROM_V2_SPI_PERIPH_MOSI_AF);
GPIO_PinAFConfig(EEPROM_V2_SPI_PERIPH_MISO_PORT, EEPROM_V2_SPI_PERIPH_MISO_RCC_SOURCE, EEPROM_V2_SPI_PERIPH_MISO_AF);
GPIO_PinAFConfig(EEPROM_V2_SPI_PERIPH_SCLK_PORT, EEPROM_V2_SPI_PERIPH_SCLK_RCC_SOURCE, EEPROM_V2_SPI_PERIPH_SCLK_AF);
/* Configure SPI pins:SCLK, MISO and MOSI */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz;
GPIO_InitStructure.GPIO_Pin = EEPROM_V2_SPI_PERIPH_SCLK_PIN;
GPIO_Init(EEPROM_V2_SPI_PERIPH_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = EEPROM_V2_SPI_PERIPH_MISO_PIN;
GPIO_Init(EEPROM_V2_SPI_PERIPH_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = EEPROM_V2_SPI_PERIPH_MOSI_PIN;
GPIO_Init(EEPROM_V2_SPI_PERIPH_MOSI_PORT, &GPIO_InitStructure);
}
else if(SdkEvalGetVersion() == SDK_EVAL_VERSION_3 || SdkEvalGetVersion() == SDK_EVAL_VERSION_D1) {
/* Enable SPI periph and SCLK, MOSI, MISO and CS GPIO clocks */
RCC_APB1PeriphClockCmd(EEPROM_V3_SPI_PERIPH_RCC, ENABLE);
RCC_AHBPeriphClockCmd(EEPROM_V3_SPI_PERIPH_MOSI_RCC | EEPROM_V3_SPI_PERIPH_MISO_RCC | EEPROM_V3_SPI_PERIPH_SCLK_RCC | EEPROM_V3_SPI_PERIPH_CS_RCC, ENABLE);
/* Configure the AF for MOSI, MISO and SCLK GPIO pins*/
GPIO_PinAFConfig(EEPROM_V3_SPI_PERIPH_MOSI_PORT, EEPROM_V3_SPI_PERIPH_MOSI_RCC_SOURCE, EEPROM_V3_SPI_PERIPH_MOSI_AF);
GPIO_PinAFConfig(EEPROM_V3_SPI_PERIPH_MISO_PORT, EEPROM_V3_SPI_PERIPH_MISO_RCC_SOURCE, EEPROM_V3_SPI_PERIPH_MISO_AF);
GPIO_PinAFConfig(EEPROM_V3_SPI_PERIPH_SCLK_PORT, EEPROM_V3_SPI_PERIPH_SCLK_RCC_SOURCE, EEPROM_V3_SPI_PERIPH_SCLK_AF);
/* Configure SPI pins:SCLK, MISO and MOSI */
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz;
GPIO_InitStructure.GPIO_Pin = EEPROM_V3_SPI_PERIPH_SCLK_PIN;
GPIO_Init(EEPROM_V3_SPI_PERIPH_SCLK_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = EEPROM_V3_SPI_PERIPH_MISO_PIN;
GPIO_Init(EEPROM_V3_SPI_PERIPH_MISO_PORT, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = EEPROM_V3_SPI_PERIPH_MOSI_PIN;
GPIO_Init(EEPROM_V3_SPI_PERIPH_MOSI_PORT, &GPIO_InitStructure);
}
/* Configure SPI pin: CS */
GPIO_InitStructure.GPIO_Pin = *s_vectnEepromSpiCsPin;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_40MHz;
GPIO_Init(*s_vectpxEepromSpiCsPort, &GPIO_InitStructure);
/* Configure SPI peripheral */
SPI_DeInit(s_EepromSpiPort);
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(s_EepromSpiPort, &SPI_InitStructure);
SPI_Cmd(s_EepromSpiPort, ENABLE);
EepromSPICSHigh();
}
static int rc522_open(struct inode *inode, struct file *file)
{
uint8_t str[MAX_LEN];
uint8_t writeData[16]={1, 2, 3, 4, 0};
uint8_t i;
uint8_t status;
uint8_t size;
uint8_t blockAddr; //选择操作的块地址0～63
//扇区A密码，16个扇区，每个扇区密码6Byte
uint8_t sectorKeyA[16][16] = {{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},};
printk("rc522_open\r\n");
SPI_Init();
MFRC522_Init();
while (1)
{
//寻卡，返回卡类型
status = MFRC522_Request(PICC_REQIDL, str);
if (status == MI_OK)
{
printk("%d \r\n", str[0]);
printk("%d \r\n", str[1]);
}
//防冲撞，返回卡的序列号 4字节
status = MFRC522_Anticoll(str);
memcpy(serNum, str, 5);
if (status == MI_OK)
{
printk("%d \r\n", serNum[0]);
printk("%d \r\n", serNum[1]);
printk("%d \r\n", serNum[2]);
printk("%d \r\n", serNum[3]);
printk("%d \r\n", serNum[4]);
}
//选卡，返回卡容量
size = MFRC522_SelectTag(serNum);
if (size != 0)
{
printk("size is %d", size);
}
//写
blockAddr = 1; //数据块
status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorKeyA[blockAddr/4], serNum); //认证
if (status == MI_OK)
{
//写数据
status = MFRC522_Write(blockAddr, writeData);
}
//读
blockAddr = 1; //数据块
status = MFRC522_Auth(PICC_AUTHENT1A, blockAddr, sectorKeyA[blockAddr/4], serNum); //认证
if (status == MI_OK)
{
//读数据
status = MFRC522_Read(blockAddr, str);
if (status == MI_OK)
{
for (i=0; i<16; i++)
{
printk("%d ", str[i]);
}
}
}
MFRC522_Halt(); //命令卡片进入休眠状态*/
}
}
void spi_init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Enable the SPI periph */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);//RCC_APB2Periph_SPI1
/* Enable SCK, MOSI and MISO GPIO clocks */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOC, ENABLE);
/* Enable CS GPIO clock */
// RCC_AHB1PeriphClockCmd(LIS302DL_SPI_CS_GPIO_CLK, ENABLE);
/* Enable INT1 GPIO clock */
//RCC_AHB1PeriphClockCmd(LIS302DL_SPI_INT1_GPIO_CLK, ENABLE);
/* Enable INT2 GPIO clock */
//RCC_AHB1PeriphClockCmd(LIS302DL_SPI_INT2_GPIO_CLK, ENABLE);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_0);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_0);
GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_0);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/* SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_Init(GPIOA, &GPIO_InitStructure);
/* SPI configuration -------------------------------------------------------*/
SPI_I2S_DeInit(SPI1);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPI1, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(SPI1, ENABLE);
/* Configure GPIO PIN for Lis Chip select */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOC, &GPIO_InitStructure);
/* Deselect : Chip Select high */
GPIO_SetBits(GPIOC,GPIO_Pin_13);
}
OSStatus host_platform_bus_init( void )
{
SPI_InitTypeDef spi_init;
DMA_InitTypeDef dma_init_structure;
GPIO_InitTypeDef gpio_init_structure;
NVIC_InitTypeDef nvic_init_structure;
MCU_CLOCKS_NEEDED();
mico_rtos_init_semaphore(&spi_transfer_finished_semaphore, 1);
/* Enable SPI_SLAVE DMA clock */
RCC_AHB1PeriphClockCmd( SPIX_DMA_CLK, ENABLE );
/* Enable SPI_SLAVE Periph clock */
SPIX_CLK_FUNCTION( SPIX_CLK, ENABLE );
/* Enable GPIO Bank B & C */
RCC_AHB1PeriphClockCmd( SPI_BUS_CLOCK_BANK_CLK | SPI_BUS_MISO_BANK_CLK | SPI_BUS_MOSI_BANK_CLK | SPI_BUS_CS_BANK_CLK | SPI_IRQ_CLK, ENABLE );
/* Enable SYSCFG. Needed for selecting EXTI interrupt line */
RCC_APB2PeriphClockCmd( RCC_APB2Periph_SYSCFG, ENABLE );
/* Setup the interrupt input for WLAN_IRQ */
gpio_init_structure.GPIO_Mode = GPIO_Mode_IN;
gpio_init_structure.GPIO_PuPd = GPIO_PuPd_NOPULL;
gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz;
gpio_init_structure.GPIO_Pin = ( 1 << SPI_IRQ_PIN );
GPIO_Init( SPI_IRQ_BANK, &gpio_init_structure );
gpio_irq_enable(SPI_IRQ_BANK, SPI_IRQ_PIN, IRQ_TRIGGER_RISING_EDGE, spi_irq_handler, 0);
/* Setup the SPI lines */
/* Setup SPI slave select GPIOs */
gpio_init_structure.GPIO_Mode = GPIO_Mode_AF;
gpio_init_structure.GPIO_OType = GPIO_OType_PP;
gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz;
gpio_init_structure.GPIO_Pin = ( 1 << SPI_BUS_CLOCK_PIN ) | ( 1 << SPI_BUS_MISO_PIN ) | ( 1 << SPI_BUS_MOSI_PIN );
GPIO_Init( SPI_BUS_CLOCK_BANK, &gpio_init_structure );
GPIO_PinAFConfig( SPI_BUS_CLOCK_BANK, SPI_BUS_CLOCK_PIN, SPIX_AF );
GPIO_PinAFConfig( SPI_BUS_MISO_BANK, SPI_BUS_MISO_PIN, SPIX_AF );
GPIO_PinAFConfig( SPI_BUS_MOSI_BANK, SPI_BUS_MOSI_PIN, SPIX_AF );
/* Setup SPI slave select GPIOs */
gpio_init_structure.GPIO_Mode = GPIO_Mode_OUT;
gpio_init_structure.GPIO_OType = GPIO_OType_PP;
gpio_init_structure.GPIO_Speed = GPIO_Speed_100MHz;
gpio_init_structure.GPIO_Pin = ( 1 << SPI_BUS_CS_PIN );
GPIO_Init( SPI_BUS_CS_BANK, &gpio_init_structure );
GPIO_SetBits( SPI_BUS_CS_BANK, ( 1 << SPI_BUS_CS_PIN ) ); /* Set CS high (disabled) */
/* Set GPIO_B[1:0] to 01 to put WLAN module into gSPI mode */
MicoGpioInitialize( (mico_gpio_t)WL_GPIO0, OUTPUT_PUSH_PULL );
MicoGpioOutputHigh( (mico_gpio_t)WL_GPIO0 );
MicoGpioInitialize( (mico_gpio_t)WL_GPIO1, OUTPUT_PUSH_PULL );
MicoGpioOutputLow( (mico_gpio_t)WL_GPIO1 );
/* Setup DMA for SPIX RX */
DMA_DeInit( SPIX_DMA_RX_STREAM );
dma_init_structure.DMA_Channel = SPIX_DMA_RX_CHANNEL;
dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &SPIX->DR;
dma_init_structure.DMA_Memory0BaseAddr = 0;
dma_init_structure.DMA_DIR = DMA_DIR_PeripheralToMemory;
dma_init_structure.DMA_BufferSize = 0;
dma_init_structure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
dma_init_structure.DMA_MemoryInc = DMA_MemoryInc_Enable;
dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
dma_init_structure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
dma_init_structure.DMA_Mode = DMA_Mode_Normal;
dma_init_structure.DMA_Priority = DMA_Priority_VeryHigh;
dma_init_structure.DMA_FIFOMode = DMA_FIFOMode_Disable;
dma_init_structure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
dma_init_structure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init( SPIX_DMA_RX_STREAM, &dma_init_structure );
/* Setup DMA for SPIX TX */
DMA_DeInit( SPIX_DMA_TX_STREAM );
dma_init_structure.DMA_Channel = SPIX_DMA_TX_CHANNEL;
dma_init_structure.DMA_PeripheralBaseAddr = (uint32_t) &SPIX->DR;
dma_init_structure.DMA_Memory0BaseAddr = 0;
dma_init_structure.DMA_DIR = DMA_DIR_MemoryToPeripheral;
dma_init_structure.DMA_BufferSize = 0;
dma_init_structure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
dma_init_structure.DMA_MemoryInc = DMA_MemoryInc_Enable;
dma_init_structure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_Byte;
dma_init_structure.DMA_MemoryDataSize = DMA_MemoryDataSize_Byte;
dma_init_structure.DMA_Mode = DMA_Mode_Normal;
dma_init_structure.DMA_Priority = DMA_Priority_VeryHigh;
dma_init_structure.DMA_FIFOMode = DMA_FIFOMode_Disable;
dma_init_structure.DMA_FIFOThreshold = DMA_FIFOThreshold_Full;
dma_init_structure.DMA_MemoryBurst = DMA_MemoryBurst_Single;
dma_init_structure.DMA_PeripheralBurst = DMA_PeripheralBurst_Single;
DMA_Init( SPIX_DMA_TX_STREAM, &dma_init_structure );
/* Must be lower priority than the value of configMAX_SYSCALL_INTERRUPT_PRIORITY */
/* otherwise FreeRTOS will not be able to mask the interrupt */
/* keep in mind that ARMCM3 interrupt priority logic is inverted, the highest value */
/* is the lowest priority */
nvic_init_structure.NVIC_IRQChannel = SPIX_DMA_RX_IRQ_CHANNEL;
nvic_init_structure.NVIC_IRQChannelPreemptionPriority = (uint8_t) 0x3;
nvic_init_structure.NVIC_IRQChannelSubPriority = 0x0;
nvic_init_structure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init( &nvic_init_structure );
DMA_ITConfig(SPIX_DMA_RX_STREAM, DMA_IT_TC, ENABLE);
/* Enable DMA for TX */
SPI_I2S_DMACmd( SPIX, SPI_I2S_DMAReq_Tx | SPI_I2S_DMAReq_Rx, ENABLE );
/* Setup SPI */
spi_init.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
spi_init.SPI_Mode = SPI_Mode_Master;
spi_init.SPI_DataSize = SPI_DataSize_8b;
spi_init.SPI_CPOL = SPI_CPOL_High;
spi_init.SPI_CPHA = SPI_CPHA_2Edge;
spi_init.SPI_NSS = SPI_NSS_Soft;
spi_init.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
spi_init.SPI_FirstBit = SPI_FirstBit_MSB;
spi_init.SPI_CRCPolynomial = (uint16_t) 7;
/* Init SPI and enable it */
SPI_Init( SPIX, &spi_init );
SPI_Cmd( SPIX, ENABLE );
MCU_CLOCKS_NOT_NEEDED();
return kNoErr;
}
void pyb_cc3000_spi_init(void) {
DEBUG_printf("pyb_cc3000_spi_init\n");
// enable SPI clock
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
// GPIO clocks should already be enabled
/*!< SPI pins configuration *************************************************/
/*!< Connect SPI pins to AF5 */
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_SPI2);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
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_DOWN;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/*
inf.baudRate = 100000; // FIXME - just slow for debug
inf.spiMode = SPIF_SPI_MODE_1; // Mode 1 CPOL= 0 CPHA= 1
*/
/*!< SPI configuration */
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; // should be correct
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; // clock is low when idle
SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge; // data latched on second edge, which is falling edge for low-idle
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; // software control
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; // clock freq = f_PCLK / this_prescale_value
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB; // should be correct
SPI_InitStructure.SPI_CRCPolynomial = 7; // ?
SPI_Init(SPI2, &SPI_InitStructure);
/*!< Enable the SPI */
SPI_Cmd(SPI2, ENABLE);
/*
// WLAN CS, EN and WALN IRQ Configuration
jshSetPinStateIsManual(WLAN_CS_PIN, false);
jshPinOutput(WLAN_CS_PIN, 1); // de-assert CS
jshSetPinStateIsManual(WLAN_EN_PIN, false);
jshPinOutput(WLAN_EN_PIN, 0); // disable WLAN
jshSetPinStateIsManual(WLAN_IRQ_PIN, true);
jshPinSetState(WLAN_IRQ_PIN, JSHPINSTATE_GPIO_IN_PULLUP); // flip into read mode with pullup
*/
// configure wlan CS and EN pins
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_25MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOC, &GPIO_InitStructure);
pyb_cc3000_set_cs(1); // de-assert CS
pyb_cc3000_set_en(0); // disable wlan
// configure EXTI on A14
EXTILine14_Config();
// wait a little (ensure that WLAN takes effect)
sys_tick_delay_ms(500); // force a 500ms delay! FIXME
}
int sflash_platform_init( int peripheral_id, void** platform_peripheral_out )
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
(void) peripheral_id; /* Unused due to single SPI Flash */
/* Enable clocks */
SFLASH_SPI_CLK_INIT( SFLASH_SPI_CLK, ENABLE );
RCC_AHB1PeriphClockCmd( SFLASH_SPI_SCK_GPIO_CLK | SFLASH_SPI_MISO_GPIO_CLK |
SFLASH_SPI_MOSI_GPIO_CLK | SFLASH_CS_CLK, ENABLE );
/* Use Alternate Functions for SPI pins */
GPIO_PinAFConfig( SFLASH_SPI_SCK_GPIO_PORT, SFLASH_SPI_SCK_SOURCE, SFLASH_SPI_SCK_AF );
GPIO_PinAFConfig( SFLASH_SPI_MISO_GPIO_PORT, SFLASH_SPI_MISO_SOURCE, SFLASH_SPI_MISO_AF );
GPIO_PinAFConfig( SFLASH_SPI_MOSI_GPIO_PORT, SFLASH_SPI_MOSI_SOURCE, SFLASH_SPI_MOSI_AF );
/* Setup pin types */
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_DOWN;
GPIO_InitStructure.GPIO_Pin = SFLASH_SPI_SCK_PIN;
GPIO_Init( SFLASH_SPI_SCK_GPIO_PORT, &GPIO_InitStructure );
GPIO_InitStructure.GPIO_Pin = SFLASH_SPI_MOSI_PIN;
GPIO_Init( SFLASH_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure );
GPIO_InitStructure.GPIO_Pin = SFLASH_SPI_MISO_PIN;
GPIO_Init( SFLASH_SPI_MISO_GPIO_PORT, &GPIO_InitStructure );
/* Chip select is used as a GPIO */
GPIO_InitStructure.GPIO_Pin = SFLASH_CS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init( SFLASH_CS_PORT, &GPIO_InitStructure );
/* Deselect flash initially */
GPIO_SetBits( SFLASH_CS_PORT, SFLASH_CS_PIN );
/*!< SPI 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_8;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SFLASH_SPI, &SPI_InitStructure);
/* Enable the SPI peripheral */
SPI_Cmd(SFLASH_SPI, ENABLE);
*platform_peripheral_out = (void*)SFLASH_SPI;
return 0;
}
int main() {
packet act_packet;
// setup ports/uart
nrk_setup_ports();
nrk_setup_uart(UART_BAUDRATE_115K2);
SPI_Init();
pwr_init();
nrk_init ();
nrk_time_set (0, 0);
// clear all LEDs
nrk_led_clr(0);
nrk_led_clr(1);
nrk_led_clr(2);
nrk_led_clr(3);
// flags
g_verbose = FALSE;
g_network_joined = FALSE;
g_global_outlet_state = OFF;
g_button_pressed = FALSE;
// mutexs
g_net_tx_buf_mux = nrk_sem_create(1, 8);
g_act_queue_mux = nrk_sem_create(1, 8);
g_cmd_tx_queue_mux = nrk_sem_create(1, 8);
g_data_tx_queue_mux = nrk_sem_create(1, 8);
g_seq_num_mux = nrk_sem_create(1, 8);
g_network_joined_mux = nrk_sem_create(1, 8);
g_global_outlet_state_mux = nrk_sem_create(1, 8);
g_button_pressed_mux = nrk_sem_create(1, 8);
g_net_watchdog_mux = nrk_sem_create(1, 8);
// sensor periods (in seconds / 2)
g_pwr_period = 2;
g_temp_period = 3;
g_light_period = 4;
// packet queues
packet_queue_init(&g_act_queue);
packet_queue_init(&g_cmd_tx_queue);
packet_queue_init(&g_data_tx_queue);
// ensure node is initially set to "OFF"
act_packet.source_id = MAC_ADDR;
act_packet.type = MSG_CMD;
act_packet.seq_num = 0;
act_packet.num_hops = 0;
act_packet.payload[CMD_CMDID_INDEX] = (uint16_t)0;
act_packet.payload[CMD_NODE_ID_INDEX] = MAC_ADDR;
act_packet.payload[CMD_ACT_INDEX] = OFF;
atomic_push(&g_act_queue, &act_packet, g_act_queue_mux);
// initialize bmac
bmac_task_config ();
bmac_init(13);
nrk_register_drivers();
nrk_set_gpio();
nrk_create_taskset();
nrk_start ();
return 0;
}
/* Private functions */
static void TM_SPIx_Init(SPI_TypeDef* SPIx, TM_SPI_PinsPack_t pinspack, TM_SPI_Mode_t SPI_Mode, uint16_t SPI_BaudRatePrescaler, uint16_t SPI_MasterSlave, uint16_t SPI_FirstBit) {
SPI_InitTypeDef SPI_InitStruct;
/* Set default settings */
SPI_StructInit(&SPI_InitStruct);
#ifdef USE_SPI1
if (SPIx == SPI1) {
/* Enable SPI clock */
RCC->APB2ENR |= RCC_APB2ENR_SPI1EN;
/* Init pins */
TM_SPI1_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI1_DATASIZE;
}
#endif
#ifdef USE_SPI2
if (SPIx == SPI2) {
/* Enable SPI clock */
RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;
/* Init pins */
TM_SPI2_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI2_DATASIZE;
}
#endif
#ifdef USE_SPI3
if (SPIx == SPI3) {
/* Enable SPI clock */
RCC->APB1ENR |= RCC_APB1ENR_SPI3EN;
/* Init pins */
TM_SPI3_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI3_DATASIZE;
}
#endif
#ifdef USE_SPI4
if (SPIx == SPI4) {
/* Enable SPI clock */
RCC->APB2ENR |= RCC_APB2ENR_SPI4EN;
/* Init pins */
TM_SPI4_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI4_DATASIZE;
}
#endif
#ifdef USE_SPI5
if (SPIx == SPI5) {
/* Enable SPI clock */
RCC->APB2ENR |= RCC_APB2ENR_SPI5EN;
/* Init pins */
TM_SPI5_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI5_DATASIZE;
}
#endif
#ifdef USE_SPI6
if (SPIx == SPI6) {
/* Enable SPI clock */
RCC->APB2ENR |= RCC_APB2ENR_SPI6EN;
/* Init pins */
TM_SPI6_INT_InitPins(pinspack);
/* Set options */
SPI_InitStruct.SPI_DataSize = TM_SPI6_DATASIZE;
}
#endif
/* Fill SPI settings */
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler;
SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit;
SPI_InitStruct.SPI_Mode = SPI_MasterSlave;
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft;
//SPI_InitStruct.SPI_DataSize = SPI_DataSize_16b;
/* SPI mode */
if (SPI_Mode == TM_SPI_Mode_0) {
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
} else if (SPI_Mode == TM_SPI_Mode_1) {
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;
} else if (SPI_Mode == TM_SPI_Mode_2) {
SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge;
} else if (SPI_Mode == TM_SPI_Mode_3) {
SPI_InitStruct.SPI_CPOL = SPI_CPOL_High;
SPI_InitStruct.SPI_CPHA = SPI_CPHA_2Edge;
}
/* Disable first */
SPIx->CR1 &= ~SPI_CR1_SPE;
/* Init SPI */
SPI_Init(SPIx, &SPI_InitStruct);
/* Enable SPI */
SPIx->CR1 |= SPI_CR1_SPE;
}
//----组件初始化2-----------------------------------------------------------
//功能：可选组件初始化函数共有3个:
// 1、sys_module_init，在sys_init.c中，参见该函数注释
// 2、prj_module_init，在这里初始化的模块，需要调用跟具体工程相关的代码，例
// 如键盘模块，除了调用module_init_keyboard函数外，还要调用跟硬件相关的
// module_init_keyboard_hard函数。
// 前两步初始化时，块相联分配方式还没有初始化，驱动中如果用到动态分配，使用
// 的是准静态分配，关于准静态分配的说明，参见mems.c文件。
// 3、run_module_init，参见该函数注释。
//参数：无
//返回：无
//-----------------------------------------------------------------------------
void Sys_ModuleInit(void)
{
tagDevHandle char_term_hdl;
u32 stdinout;
uint16_t evtt_main;
//初始化PutChark,Putsk,GetChark,GetsK四个内核级输入输出函数,此后,printk
//可以正常使用.printf和scanf将调用前述4个函数执行输入输出
Stddev_KnlInOutInit( 0 );
//shell模块,依赖:无
Sh_MoudleInit(0);
//文件系统模块,依赖:shell
// Djyfs_ModuleInit(0);
//设备驱动模块
Driver_ModuleInit(0);
//多路复用模块,提供类似Linux的epoll、select的功能
Multiplex_ModuleInit(0);
//提供在shell上输出内核信息的功能,依赖:shell模块
Debug_InfoInit(0);
//异常监视模块,依赖:shell模块
Exp_ModuleInit(0);
//安装异常信息解析器,解析异常模块记录的二进制数据
Exp_InfoDecoderInit( );
UART_ModuleInit(CN_UART0);
UART_ModuleInit(CN_UART1);
//标准IO初始化,不影响printk函数,此后,printf和scanf将使用stdin/out输出和输
//入,如果裁掉,将一直用PutChark,Putsk,GetChark,GetsK执行IO
//依赖: 若stdin/out/err是文件,则依赖文件系统
// 若是设备,则依赖设备驱动
// 同时,还依赖用来输出信息的设施,例如串口,LCD等
Stddev_ModuleInit( 0 );
//打开IO设备,不同的板件,这部分可能区别比较大.
stdinout = Driver_FindDevice(gc_pCfgStddevName);
char_term_hdl = Driver_OpenDeviceAlias(stdinout,O_RDWR,0);
if(char_term_hdl != NULL)
{
Driver_CtrlDevice(char_term_hdl,CN_UART_START,0,0);
//设置串口波特率为115200，
Driver_CtrlDevice(char_term_hdl,CN_UART_SET_BAUD,115200,0);
CharTerm_ModuleInit((ptu32_t)stdinout);
Driver_CloseDevice(char_term_hdl);
}
//djybus模块
DjyBus_ModuleInit(0);
//IIC总线模块,依赖:djybus
ModuleInit_IICBus(0);
//SPI总线模块,依赖:djybus
ModuleInit_SPIBus(0);
SPI_Init();
IIC0_Init();
// IIC1_Init();
//日历时钟模块
// TM_ModuleInit(0);
//使用硬件RTC,注释掉则使用tick做RTC计时,依赖:日历时钟模块
// RTC_ModuleInit(0);
//定时器组件
// module_init_timersoft(0);
//键盘输入模块
// Keyboard_ModuleInit(0);
//键盘输入驱动,依赖:键盘输入模块
// module_init_keyboard_hard(0);
//字符集模块
// Charset_ModuleInit(0);
//gb2312字符编码,依赖:字符集模块
// Charset_Gb2312ModuleInit(0);
//ascii字符集,注意,gb2312包含了ascii,初始化了gb2312后,无须本模块
//依赖:字符集模块
// Charset_AsciiModuleInit(0);
//初始化utf8字符集
// Charset_Utf8ModuleInit(0);
//国际化字符集支持,依赖所有字符集模块以及具体字符集初始化
// Charset_NlsModuleInit("C");
// Font_ModuleInit(0); //字体模块
//8*8点阵的ascii字体依赖:字体模块
// Font_Ascii8x8FontModuleInit(0);
//6*12点阵的ascii字体依赖:字体模块
// Font_Ascii6x12FontModuleInit(0);
//从数组安装GB2312点阵字体,包含了8*16的ascii字体.依赖:字体模块
// Font_Gb2312_816_1616_ArrayModuleInit(0);
//从文件安装GB2312点阵字体,包含了8*16的ascii字体.依赖:字体模块,文件系统
// Font_Gb2312_816_1616_FileModuleInit("sys:\\gb2312_1616");
//8*16 ascii字体初始化,包含高128字节,依赖:字体模块
//注:如果安装了GB2312,无须再安装
// Font_Ascii8x16FontModuleInit(0);
//看门狗模块,如果启动了加载时喂硬件狗,看门狗软件模块从此开始接管硬件狗.
// module_init_wdt(0);
//事件的两个参数暂设为0,如果用shell启动,可用来采集shell命令行参数
evtt_main = Djy_EvttRegist(EN_CORRELATIVE,CN_PRIO_RRS,0,0,__djy_main,
NULL,gc_u32CfgMainStackLen,"main function");
//事件的两个参数暂设为0，如果用shell启动，可用来采集shell命令行参数
Djy_EventPop(evtt_main,NULL,0,NULL,0,200);
Heap_DynamicModuleInit(0);//自此malloc函数执行块相联算法
//至此,初始化时使用的栈,已经被系统回收,本函数就此结束,否则会死得很难看
return ;
}
int main (void)
{
/* Initialize TWI master. */
TWI_MasterInit(&twiMaster,&TWIF,TWI_MASTER_INTLVL_LO_gc,TWI_BAUDSETTING);
TWIF.SLAVE.CTRLA=0; //slave disabled
//board_init();
En_RC32M();
//Enable LowLevel & HighLevel Interrupts
PMIC_CTRL |= PMIC_HILVLEN_bm | PMIC_LOLVLEN_bm |PMIC_MEDLVLEN_bm;
PORT_init();
TimerD0_init();
TimerC0_init();
//USARTE0_init();
//ADCB_init();
LCDInit();
//wdt_enable();
// Globally enable interrupts
sei();
LED_Green_Time = 3000;
LED_Green_Speed = 500;
LED_Red_Time = 3000;
LED_Red_Speed = 100;
LED_White_Time = 1000;
LED_White_Speed = 200;
Buzzer_Time = 2000;
Buzzer_Speed = 150;
///////////////////////////////////////////////////////////////////////////////////////////////Begin NRF Initialize
NRF24L01_L_CE_LOW; //disable transceiver modes
SPI_Init();
_delay_us(10);
_delay_ms(100); //power on reset delay needs 100ms
NRF24L01_L_Clear_Interrupts();
NRF24L01_L_Flush_TX();
NRF24L01_L_Flush_RX();
NRF24L01_L_CE_LOW;
NRF24L01_L_Init_milad(_TX_MODE, _CH, _2Mbps, Address, _Address_Width, _Buffer_Size, RF_PWR_MAX);
NRF24L01_L_WriteReg(W_REGISTER | DYNPD,0x01);
NRF24L01_L_WriteReg(W_REGISTER | FEATURE,0x06);
NRF24L01_L_CE_HIGH;
_delay_us(130);
///////////////////////////////////////////////////////////////////////////////////////////////END NRF Initialize
// Insert application code here, after the board has been initialized.
while(1)
{
LCDGotoXY(0,0);
sprintf("salam");
//LCDStringRam(str);
////////TWI
//tx1[0]=Robot_D[RobotID].M1;
//tx2[0]=Robot_D[RobotID].M2;
//tx3[0]=Robot_D[RobotID].M3;
//tx4[0]=Robot_D[RobotID].M4;
tx1[0]=0x0F;
tx2[0]=0x12;
tx3[0]=0x01;
tx4[0]=0x02;
// TWI_MasterWriteRead(&twiMaster,SLAVE1_ADDRESS,&tx1[0],1,3);
// TWI_MasterWriteRead(&twiMaster,SLAVE2_ADDRESS,&tx2[0],1,3);
TWI_MasterWriteRead(&twiMaster,SLAVE3_ADDRESS,&tx3[0],1,3);
rx3[0]=twiMaster.readData[0];
if (rx3[0]==1)
{
LED_White(ON);
}
// TWI_MasterWriteRead(&twiMaster,SLAVE4_ADDRESS,&tx4[0],1,3);
/////////////////////
NRF24L01_L_Write_TX_Buf(Buf_Tx_L, _Buffer_Size);
NRF24L01_L_RF_TX();
if (Buf_Rx_L[0]=='f')
{
LED_Green_PORT.OUTTGL = LED_Green_PIN_bm;
}
_delay_ms(10);
}
}
void SST25V_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Enable DF_SPI Periph clock */
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOB,ENABLE);
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2,ENABLE);
GPIO_PinAFConfig(GPIOB, GPIO_PinSource13, GPIO_AF_SPI2 );
GPIO_PinAFConfig(GPIOB, GPIO_PinSource14, GPIO_AF_SPI2 );
GPIO_PinAFConfig(GPIOB, GPIO_PinSource15, GPIO_AF_SPI2 );
RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOD, ENABLE);
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_DOWN;
/*!< SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/*!< SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
GPIO_Init(GPIOB, &GPIO_InitStructure);
/*!< SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_Init(GPIOB, &GPIO_InitStructure);
//------- CS _pin
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
//------- WP _pin
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOD, &GPIO_InitStructure);
/*------------------------ DF_SPI configuration ------------------------*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;//SPI_Direction_1Line_Tx;
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;/* 72M/64=1.125M */
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
//SPI1->CR2=0x04; //NSS ---SSOE
// SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
//SPI_InitStructure.SPI_Mode = SPI_Mode_Master; //MSTR
SPI_I2S_DeInit(DF_SPI);
SPI_Init(DF_SPI, &SPI_InitStructure);
/* Enable SPI_MASTER */
SPI_Cmd(DF_SPI, ENABLE);
SPI_CalculateCRC(DF_SPI, DISABLE);
SST25V_CS_HIGH();
SST25V_WP_HIGH();
//SST25V_HOLD_HIGH();
// SST25V_EnableWriteStatusRegister();
// SST25V_WriteStatusRegister(0x02);
SST25V_DBSY();
}
void SPI1_SetSpeed(u8 SpeedSet)
{
SPI_InitStructure.SPI_BaudRatePrescaler = SpeedSet ;
SPI_Init(SPI1, &SPI_InitStructure);
SPI_Cmd(SPI1,ENABLE);
}
/*********************************************************************//**
* @brief c_entry: Main SPI program body
* @param[in] None
* @return int
**********************************************************************/
int c_entry(void)
{
PINSEL_CFG_Type PinCfg;
SPI_DATA_SETUP_Type xferConfig;
uint32_t tmp;
/*
* Initialize SPI pin connect
* P0.15 - SCK;
* P0.16 - SSEL - used as GPIO
* P0.17 - MISO
* P0.18 - MOSI
*/
PinCfg.Funcnum = 3;
PinCfg.OpenDrain = 0;
PinCfg.Pinmode = 0;
PinCfg.Portnum = 0;
PinCfg.Pinnum = 15;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 17;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 18;
PINSEL_ConfigPin(&PinCfg);
PinCfg.Pinnum = 16;
PinCfg.Funcnum = 0;
PINSEL_ConfigPin(&PinCfg);
/* Initialize debug via UART0
* – 115200bps
* – 8 data bit
* – No parity
* – 1 stop bit
* – No flow control
*/
debug_frmwrk_init();
// print welcome screen
print_menu();
SPI_ConfigStruct.CPHA = SPI_CPHA_SECOND;
SPI_ConfigStruct.CPOL = SPI_CPOL_LO;
SPI_ConfigStruct.ClockRate = 2000000;
SPI_ConfigStruct.DataOrder = SPI_DATA_MSB_FIRST;
SPI_ConfigStruct.Databit = SPI_DATABIT_SIZE;
SPI_ConfigStruct.Mode = SPI_MASTER_MODE;
// Initialize SPI peripheral with parameter given in structure above
SPI_Init(LPC_SPI, &SPI_ConfigStruct);
_DBG_("Press '1' to start transfer...");
while (_DG != '1');
_DBG_("Init buffer");
/* Initialize Buffer */
Buffer_Init();
CS_Init();
_DBG_("Start transfer...");
CS_Force(0);
// delay for a while
for (tmp = 10000; tmp; tmp--);
xferConfig.tx_data = Tx_Buf;
xferConfig.rx_data = Rx_Buf;
xferConfig.length = BUFFER_SIZE;
SPI_ReadWrite(LPC_SPI, &xferConfig, SPI_TRANSFER_POLLING);
// delay for a while
for (tmp = 10000; tmp; tmp--);
CS_Force(1);
_DBG_("Complete!");
// Verify buffer after transferring
Buffer_Verify();
_DBG_("Verify complete!");
SPI_DeInit(LPC_SPI);
/* Loop forever */
while(1);
return 1;
}
/*====================================================================================================*/
void NRF24L01_Config( void )
{
GPIO_InitTypeDef GPIO_InitStruct;
SPI_InitTypeDef SPI_InitStruct;
/* Clk Init *************************************************************/
RCC_AHB1PeriphClockCmd(NRF_CE_GPIO_CLK | NRF_IRQ_GPIO_CLK | NRF_CSN_GPIO_CLK |
NRF_SCK_GPIO_CLK | NRF_SDO_GPIO_CLK | NRF_SDI_GPIO_CLK, ENABLE);
RCC_APB1PeriphClockCmd(NRF_SPIx_CLK, ENABLE);
GPIO_PinAFConfig(NRF_SCK_GPIO_PORT, NRF_SCK_SOURCE, NRF_SCK_AF);
GPIO_PinAFConfig(NRF_SDO_GPIO_PORT, NRF_SDO_SOURCE, NRF_SDO_AF);
GPIO_PinAFConfig(NRF_SDI_GPIO_PORT, NRF_SDI_SOURCE, NRF_SDI_AF);
/* CE */
GPIO_InitStruct.GPIO_Pin = NRF_CE_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_CE_GPIO_PORT, &GPIO_InitStruct);
NRF_CE = 0;
/* IRQ */
GPIO_InitStruct.GPIO_Pin = NRF_IRQ_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_OD;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_IRQ_GPIO_PORT, &GPIO_InitStruct);
/* CSN */
GPIO_InitStruct.GPIO_Pin = NRF_CSN_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_CSN_GPIO_PORT, &GPIO_InitStruct);
NRF_CSN = 1;
/* SCK */
GPIO_InitStruct.GPIO_Pin = NRF_SCK_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_SCK_GPIO_PORT, &GPIO_InitStruct);
/* SDO */
GPIO_InitStruct.GPIO_Pin = NRF_SDO_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_SDO_GPIO_PORT, &GPIO_InitStruct);
/* SDI */
GPIO_InitStruct.GPIO_Pin = NRF_SDI_PIN;
GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStruct.GPIO_OType = GPIO_OType_PP;
GPIO_InitStruct.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(NRF_SDI_GPIO_PORT, &GPIO_InitStruct);
/* SPI Init ****************************************************************/
SPI_InitStruct.SPI_Direction = SPI_Direction_2Lines_FullDuplex; // Full Duplex
SPI_InitStruct.SPI_Mode = SPI_Mode_Master; // Master Mode
SPI_InitStruct.SPI_DataSize = SPI_DataSize_8b; // Data Size 8 bit
SPI_InitStruct.SPI_CPOL = SPI_CPOL_Low; // Transitioned On The Rising Edge
SPI_InitStruct.SPI_CPHA = SPI_CPHA_1Edge; // Latched On the Rising Edge
SPI_InitStruct.SPI_NSS = SPI_NSS_Soft; // Software NSS Signal
SPI_InitStruct.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2; // fsck = APB1 36MHz / 2 = 18MHz
SPI_InitStruct.SPI_FirstBit = SPI_FirstBit_MSB; // MSB First
SPI_InitStruct.SPI_CRCPolynomial = 7;
SPI_Init(NRF_SPIx, &SPI_InitStruct);
SPI_Cmd(NRF_SPIx, ENABLE);
}
/**
* @brief Initializes the SD Card and put it into StandBy State (Ready for
* data transfer).
* @param None
* @retval None
*/
void SD_LowLevel_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/*!< SD_SPI_CS_GPIO, SD_SPI_MOSI_GPIO, SD_SPI_MISO_GPIO, SD_SPI_DETECT_GPIO
and SD_SPI_SCK_GPIO Periph clock enable */
RCC_AHBPeriphClockCmd(SD_CS_GPIO_CLK | SD_SPI_MOSI_GPIO_CLK | SD_SPI_MISO_GPIO_CLK |
SD_SPI_SCK_GPIO_CLK | SD_DETECT_GPIO_CLK, ENABLE);
/*!< SD_SPI Periph clock enable */
RCC_APB2PeriphClockCmd(SD_SPI_CLK, ENABLE);
/*!< Configure SD_SPI pins: SCK */
GPIO_InitStructure.GPIO_Pin = SD_SPI_SCK_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(SD_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
/*!< Configure SD_SPI pins: MISO */
GPIO_InitStructure.GPIO_Pin = SD_SPI_MISO_PIN;
GPIO_Init(SD_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
/*!< Configure SD_SPI pins: MOSI */
GPIO_InitStructure.GPIO_Pin = SD_SPI_MOSI_PIN;
GPIO_Init(SD_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
/*!< Configure SD_SPI_CS_PIN pin: SD Card CS pin */
GPIO_InitStructure.GPIO_Pin = SD_CS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(SD_CS_GPIO_PORT, &GPIO_InitStructure);
/*!< Configure SD_SPI_DETECT_PIN pin: SD Card detect pin */
GPIO_InitStructure.GPIO_Pin = SD_DETECT_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
GPIO_Init(SD_DETECT_GPIO_PORT, &GPIO_InitStructure);
/* Connect PXx to SD_SPI_SCK */
GPIO_PinAFConfig(SD_SPI_SCK_GPIO_PORT, SD_SPI_SCK_SOURCE, SD_SPI_SCK_AF);
/* Connect PXx to SD_SPI_MISO */
GPIO_PinAFConfig(SD_SPI_MISO_GPIO_PORT, SD_SPI_MISO_SOURCE, SD_SPI_MISO_AF);
/* Connect PXx to SD_SPI_MOSI */
GPIO_PinAFConfig(SD_SPI_MOSI_GPIO_PORT, SD_SPI_MOSI_SOURCE, SD_SPI_MOSI_AF);
/*!< SD_SPI Config */
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_2;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(SD_SPI, &SPI_InitStructure);
SPI_RxFIFOThresholdConfig(SD_SPI, SPI_RxFIFOThreshold_QF);
SPI_Cmd(SD_SPI, ENABLE); /*!< SD_SPI enable */
}
void glcd_init(void)
{
#if defined(GLCD_CONTROLLER_PCD8544)
/* Initialisation for PCD8544 controller */
/* Declare GPIO and SPI init structures */
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
//NVIC_InitTypeDef NVIC_InitStructure;
/* Initialise structures (which we will overide later) */
GPIO_StructInit(&GPIO_InitStructure);
SPI_StructInit(&SPI_InitStructure);
/* Need to make start up the correct peripheral clocks */
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
/* SS pin */
GPIO_InitStructure.GPIO_Pin = CONTROLLER_SPI_SS_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_Init(CONTROLLER_SPI_SS_PORT, &GPIO_InitStructure);
/* DC pin */
GPIO_InitStructure.GPIO_Pin = CONTROLLER_SPI_DC_PIN;
GPIO_Init(CONTROLLER_SPI_DC_PORT, &GPIO_InitStructure);
/* RESET pin */
GPIO_InitStructure.GPIO_Pin = CONTROLLER_SPI_RST_PIN;
GPIO_Init(CONTROLLER_SPI_RST_PORT, &GPIO_InitStructure);
/* Make sure chip is de-selected by default */
GLCD_DESELECT();
/* Set up GPIO for SPI pins */
GPIO_InitStructure.GPIO_Pin = CONTROLLER_SPI_SCK_PIN | CONTROLLER_SPI_MISO_PIN | CONTROLLER_SPI_MOSI_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_Level_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_Init(CONTROLLER_SPI_PORT, &GPIO_InitStructure);
/* Configure alternate function mode for SPI pins */
GPIO_PinAFConfig(GPIOA,CONTROLLER_SPI_SCK_PINSRC,GPIO_AF_0);
GPIO_PinAFConfig(GPIOA,CONTROLLER_SPI_MOSI_PINSRC,GPIO_AF_0);
GPIO_PinAFConfig(GPIOA,CONTROLLER_SPI_MISO_PINSRC,GPIO_AF_0);
/* Initialise SPI */
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_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_32; /* Set clock speed! */
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(CONTROLLER_SPI_NUMBER, &SPI_InitStructure);
/* Enable SPI interupts */
/*
SPI_I2S_ITConfig(CONTROLLER_SPI_NUMBER, SPI_I2S_IT_TXE, ENABLE);
NVIC_InitStructure.NVIC_IRQChannel = SPI1_IRQn;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPriority = 0x00;
NVIC_Init(&NVIC_InitStructure);
*/
/* Enable SPI */
SPI_Cmd(CONTROLLER_SPI_NUMBER, ENABLE);
/* Initialisation sequence of controller */
glcd_reset();
/* Get into the EXTENDED mode! */
glcd_command(PCD8544_FUNCTION_SET | PCD8544_EXTENDED_INSTRUCTION);
/* LCD bias select (4 is optimal?) */
glcd_command(PCD8544_SET_BIAS | 0x2);
/* Set VOP */
glcd_command(PCD8544_SET_VOP | 50); // Experimentally determined
/* Back to standard instructions */
glcd_command(PCD8544_FUNCTION_SET);
/* Normal mode */
glcd_command(PCD8544_DISPLAY_CONTROL | PCD8544_DISPLAY_NORMAL);
glcd_select_screen((uint8_t *)&glcd_buffer,&glcd_bbox);
glcd_set_contrast(50);
glcd_clear();
#else
#error "Controller not supported by STM32F0xx"
#endif
}
/*******************************************************************************
* Function Name : SPI_LCD_Init
* Description : Initializes the peripherals used by the SPI FLASH driver.
* Input : None
* Output : None
* Return : None
*******************************************************************************/
void SPI_LCD_Init(void)
{
SPI_InitTypeDef SPI_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
#if USE_SPI
/* Enable LCD_SPIx and GPIO clocks */
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);
#endif
RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIO_RS |RCC_APB2Periph_GPIO_REST |
RCC_APB2Periph_GPIO_CS, ENABLE);
#if USE_SPI
/* Configure LCD_SPIx pins: SCK, MISO and MOSI */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 /*| GPIO_Pin_14 miso*/ | GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
#else
/* Configure LCD_SPIx pins: SCK, MISO and MOSI */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15 /*| GPIO_Pin_14 miso*/ | GPIO_Pin_13;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
SPI_LCD_CLK(1);
#endif
//REST
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_REST;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_REST, &GPIO_InitStructure);
// rs pin config
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_RS;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_RS, &GPIO_InitStructure);
/* Configure I/O for Flash Chip select */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_CS;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIO_CS, &GPIO_InitStructure);
/* Deselect the FLASH: Chip Select high */
SPI_LCD_CS_HIGH();
#if USE_SPI
/* LCD_SPIx 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_2Edge;
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_4;
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
SPI_InitStructure.SPI_CRCPolynomial = 7;
SPI_Init(LCD_SPIx, &SPI_InitStructure);
/* Enable LCD_SPIx */
SPI_Cmd(LCD_SPIx, ENABLE);
#endif
}
uint16_t lcd_init(framebuffer_t *framebuffer, lcd_wait_func_t wait_func)
{
uint16_t i;
// use framebuffer
lcd_state.framebuffer = framebuffer;
// scrolling is on by default, if we have a framebuffer
// UTF-8 is on by default, because I use Eclipse
lcd_state.flags = framebuffer != NULL ? LCD_FLAG_SCROLL|LCD_FLAG_UTF8CYR : LCD_FLAG_UTF8CYR;
// use user :) wait function or default one
lcd_state.wait_func = wait_func == NULL ? lcd_dumb_wait : wait_func;
// init clocks
RCC_APB2PeriphClockCmd(LCD_SPI_CLK, ENABLE);
RCC_AHBPeriphClockCmd(LCD_GPIO_CLK, ENABLE);
/*
* init GPIOs.
* since there be no reading, MISO is not used,
* and pin is configured as output GPIO for RESET signal
*/
// switch SCK and MOSI pins to alternate function
GPIO_PinAFConfig(LCD_PORT, LCD_SCK_PIN_NUM, GPIO_AF_0);
GPIO_PinAFConfig(LCD_PORT, LCD_MOSI_PIN_NUM, GPIO_AF_0);
// set common parameters
lcd_gpio_config.GPIO_Mode = GPIO_Mode_AF;
lcd_gpio_config.GPIO_OType = GPIO_OType_PP;
lcd_gpio_config.GPIO_PuPd = GPIO_PuPd_NOPULL;
lcd_gpio_config.GPIO_Speed = GPIO_Speed_50MHz;
// config SCK pin
lcd_gpio_config.GPIO_Pin = LCD_SCK_PIN;
GPIO_Init(LCD_PORT, &lcd_gpio_config);
// config MOSI pin
lcd_gpio_config.GPIO_Pin = LCD_MOSI_PIN;
GPIO_Init(LCD_PORT, &lcd_gpio_config);
// config MISO pin
lcd_gpio_config.GPIO_Mode = GPIO_Mode_OUT;
lcd_gpio_config.GPIO_Pin = LCD_RESET_PIN;
GPIO_Init(LCD_PORT, &lcd_gpio_config);
/*
* init SPI
* hell bunch of configurations :-\
*/
// just in case
SPI_I2S_DeInit(LCD_SPI);
// config SPI
lcd_spi_config.SPI_Direction = SPI_Direction_1Line_Tx;
lcd_spi_config.SPI_Mode = SPI_Mode_Master;
lcd_spi_config.SPI_DataSize = SPI_DataSize_9b;
lcd_spi_config.SPI_CPOL = SPI_CPOL_Low;
lcd_spi_config.SPI_CPHA = SPI_CPHA_1Edge;
// lcd_spi_config.SPI_CPOL = SPI_CPOL_High;
// lcd_spi_config.SPI_CPHA = SPI_CPHA_2Edge;
lcd_spi_config.SPI_NSS = SPI_NSS_Soft;
lcd_spi_config.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_2;
lcd_spi_config.SPI_FirstBit = SPI_FirstBit_MSB;
lcd_spi_config.SPI_CRCPolynomial = 7; // ?
SPI_Init(LCD_SPI, &lcd_spi_config);
// enable NSS
SPI_NSSInternalSoftwareConfig(LCD_SPI, SPI_NSSInternalSoft_Set);
// enable SPI
SPI_Cmd(LCD_SPI, ENABLE);
// finally, send RESET signal
GPIO_ResetBits(LCD_PORT, LCD_RESET_PIN);
lcd_state.wait_func(5); // let RESET last 5 msec!
GPIO_SetBits(LCD_PORT, LCD_RESET_PIN);
// // send Reading Mode command
// lcd_write_command(0xdb);
// // switch SPI to read
// SPI_BiDirectionalLineConfig(LCD_SPI, SPI_Direction_Rx);
// while(SPI_GetReceptionFIFOStatus(LCD_SPI) < SPI_ReceptionFIFOStatus_HalfFull);
// data = SPI_I2S_ReceiveData16(LCD_SPI);
// // switch SPI back to write
// SPI_BiDirectionalLineConfig(LCD_SPI, SPI_Direction_Tx);
// send command of internal display reset
lcd_write_command(0xE2);
// wait...
lcd_state.wait_func(20);
// send init commands to display
for(i = 0; i < sizeof(lcd_init_sequence); i++)
lcd_write_command(lcd_init_sequence[i]);
return 0;
}
/*******************************************************************************
* Function Name : RFID_Operate
* Description : Output segment to LED.
* Input : - numb : display number.
* Output : None
* Return : None
*******************************************************************************/
uint8_t RFID_Operate(uint8_t *tbuf, uint8_t *rbuf)
{
uint8_t chksum;
uint32_t i, j, rnumb;
SPI_Init(0, 8, 128);
chksum = RFID_CheckSum(tbuf);
SPI0_Send(0, 0xaa);
//delay_ms(1);
i = 0;
rbuf[i] = SPI0_Send(0, 0xbb);
i ++;
//delay_ms(1);
for(j=0; j<tbuf[0]; j++)
{
rbuf[i] = SPI0_Send(0, tbuf[j]);
i ++;
Delay_ms(1);
}
rbuf[i] = SPI0_Send(0, chksum);
i ++;
Delay_ms(200);
rbuf[0] = 1;
if(SPI0_Send(0, 0) != 0xaa)
{
SPI_Init(0, 8, 2);
return 0;
}
Delay_ms(1);
if(SPI0_Send(0, 0) != 0xbb)
{
SPI_Init(0, 8, 2);
return 0;
}
Delay_ms(1);
switch(tbuf[1])
{
case 0x01:
rnumb = 8 + 2 + 1;
break;
case 0x20:
rnumb = 4 + 2 + 1;
break;
case 0x21:
rnumb = 16 + 2 + 1;
break;
case 0x22:
rnumb = 2 + 1;
break;
default:
rnumb = 4 + 2 + 1;
break;
}
for(j=0, i=0; j<=rnumb; j++, i++)
{
rbuf[i] = SPI0_Send(0, 0);
Delay_ms(1);
}
SPI_Init(0, 8, 2);
return i;
}
/**
* @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
files (startup_stm32f40_41xxx.s/startup_stm32f427_437xx.s/startup_stm32f429_439xx.s)
before to branch to application main.
*/
/* SPI configuration */
SPI_Config();
/* SysTick configuration */
SysTickConfig();
/* LEDs configuration */
STM_EVAL_LEDInit(LED1);
STM_EVAL_LEDInit(LED2);
STM_EVAL_LEDInit(LED3);
STM_EVAL_LEDInit(LED4);
#ifdef SPI_MASTER
/* Master board configuration */
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(SPIx, &SPI_InitStructure);
/* The Data transfer is performed in the SPI interrupt routine */
/* Configure the Tamper Button */
STM_EVAL_PBInit(BUTTON_TAMPER,BUTTON_MODE_GPIO);
/* Wait until Tamper Button is pressed */
while (STM_EVAL_PBGetState(BUTTON_TAMPER));
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
/* Initialize Buffer counters */
ubTxIndex = 0;
ubRxIndex = 0;
/* Enable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, ENABLE);
/* Enable the Tx buffer empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, ENABLE);
#endif /* SPI_MASTER */
#ifdef SPI_SLAVE
/* Slave board configuration */
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Slave;
SPI_Init(SPIx, &SPI_InitStructure);
/* The Data transfer is performed in the SPI interrupt routine */
/* Initialize Buffer counters */
ubTxIndex = 0;
ubRxIndex = 0;
/* Enable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, ENABLE);
/* Enable the Tx empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, ENABLE);
/* Enable the SPI peripheral */
SPI_Cmd(SPIx, ENABLE);
#endif /* SPI_SLAVE */
/* Waiting the end of Data transfer */
while ((ubTxIndex < BUFFERSIZE) && (ubRxIndex < BUFFERSIZE))
{
}
/* Disable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_RXNE, DISABLE);
/* Disable the Tx empty interrupt */
SPI_I2S_ITConfig(SPIx, SPI_I2S_IT_TXE, DISABLE);
/* Disable the SPI peripheral */
SPI_Cmd(SPIx, DISABLE);
if (Buffercmp(aTxBuffer, aRxBuffer, BUFFERSIZE) != FAILED)
{
/* Turn ON LED1 and LED3 */
STM_EVAL_LEDOn(LED1);
STM_EVAL_LEDOn(LED3);
/* Turn OFF LED2 and LED4 */
STM_EVAL_LEDOff(LED2);
STM_EVAL_LEDOff(LED4);
}
else
{
/* Turn OFF LED1 and LED3 */
STM_EVAL_LEDOff(LED1);
STM_EVAL_LEDOff(LED3);
/* Turn ON LED2 and LED4 */
STM_EVAL_LEDOn(LED2);
STM_EVAL_LEDOn(LED4);
}
/* Infinite Loop */
while (1)
{
}
}
/**
* @brief Initializes the low level interface used to drive the cc2500
* @param None
* @retval None
*/
void cc2500_LowLevel_Init(void)
{
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Enable the SPI periph */
RCC_APB1PeriphClockCmd(CC2500_SPI_CLK, ENABLE);
/* Enable SCK, MOSI and MISO GPIO clocks */
RCC_AHB1PeriphClockCmd(CC2500_SPI_SCK_GPIO_CLK | CC2500_SPI_MISO_GPIO_CLK | CC2500_SPI_MOSI_GPIO_CLK, ENABLE);
/* Enable CS GPIO clock */
RCC_AHB1PeriphClockCmd(CC2500_SPI_CS_GPIO_CLK, ENABLE);
/* Enable GDO0 GPIO clock */
RCC_AHB1PeriphClockCmd(CC2500_SPI_GDO0_GPIO_CLK, ENABLE);
GPIO_PinAFConfig(CC2500_SPI_SCK_GPIO_PORT, CC2500_SPI_SCK_SOURCE, CC2500_SPI_SCK_AF);
GPIO_PinAFConfig(CC2500_SPI_MISO_GPIO_PORT, CC2500_SPI_MISO_SOURCE, CC2500_SPI_MISO_AF);
GPIO_PinAFConfig(CC2500_SPI_MOSI_GPIO_PORT, CC2500_SPI_MOSI_SOURCE, CC2500_SPI_MOSI_AF);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_DOWN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
/* SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = CC2500_SPI_SCK_PIN;
GPIO_Init(CC2500_SPI_SCK_GPIO_PORT, &GPIO_InitStructure);
/* SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = CC2500_SPI_MOSI_PIN;
GPIO_Init(CC2500_SPI_MOSI_GPIO_PORT, &GPIO_InitStructure);
/* SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = CC2500_SPI_MISO_PIN;
GPIO_Init(CC2500_SPI_MISO_GPIO_PORT, &GPIO_InitStructure);
/* SPI configuration -------------------------------------------------------*/
SPI_I2S_DeInit(CC2500_SPI);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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_32; // Baudrate set to 32, gives a frequency of 5.25 MHz by dividing bus fequency of 168MHz by 32. The maximum possible frequency is 6.5 MHz for burst access as specified in the data sheet of the ez430 CC2500 chipset
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
// SPI_InitStructure.SPI_CRCPolynomial = 7; //// what is this why do we need it????
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(CC2500_SPI, &SPI_InitStructure);
/* Enable SPI1 */
SPI_Cmd(CC2500_SPI, ENABLE);
/* Configure GPIO PIN for Lis Chip select */
GPIO_InitStructure.GPIO_Pin = CC2500_SPI_CS_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_OUT;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(CC2500_SPI_CS_GPIO_PORT, &GPIO_InitStructure);
/* Deselect : Chip Select high */
GPIO_SetBits(CC2500_SPI_CS_GPIO_PORT, CC2500_SPI_CS_PIN);
/* Configure GPIO PINs to detect Interrupts */
GPIO_InitStructure.GPIO_Pin = CC2500_SPI_GDO0_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN;
GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(CC2500_SPI_GDO0_GPIO_PORT, &GPIO_InitStructure);
cc2500_configure_registers();
}
void BSP_SPI_Init( void )
{
GPIO_InitTypeDef GPIO_InitStructure;
// NVIC_InitTypeDef NVIC_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
/* Peripheral Clock Enable -------------------------------------------------*/
/* Enable the SPI clock */
BSP_SPIx_CLK_INIT(BSP_SPIx_CLK, ENABLE);
/* Enable GPIO clocks */
RCC_AHB1PeriphClockCmd( BSP_SPIx_NSS_GPIO_CLK |
BSP_SPIx_SCK_GPIO_CLK |
BSP_SPIx_MISO_GPIO_CLK |
BSP_SPIx_MOSI_GPIO_CLK , ENABLE);
/* Connect SPI pins to AF5 */
GPIO_PinAFConfig(BSP_SPIx_SCK_GPIO_PORT, BSP_SPIx_SCK_SOURCE, BSP_SPIx_SCK_AF);
GPIO_PinAFConfig(BSP_SPIx_MISO_GPIO_PORT, BSP_SPIx_MISO_SOURCE, BSP_SPIx_MISO_AF);
GPIO_PinAFConfig(BSP_SPIx_MOSI_GPIO_PORT, BSP_SPIx_MOSI_SOURCE, BSP_SPIx_MOSI_AF);
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_DOWN;
/* SPI SCK pin configuration */
GPIO_InitStructure.GPIO_Pin = BSP_SPIx_SCK_PIN;
GPIO_Init(BSP_SPIx_SCK_GPIO_PORT, &GPIO_InitStructure);
/* SPI MISO pin configuration */
GPIO_InitStructure.GPIO_Pin = BSP_SPIx_MISO_PIN;
GPIO_Init(BSP_SPIx_MISO_GPIO_PORT, &GPIO_InitStructure);
/* SPI MOSI pin configuration */
GPIO_InitStructure.GPIO_Pin = BSP_SPIx_MOSI_PIN;
GPIO_Init(BSP_SPIx_MOSI_GPIO_PORT, &GPIO_InitStructure);
/* SPI configuration -------------------------------------------------------*/
SPI_I2S_DeInit(BSP_SPIx);
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
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;
/* Configure the Priority Group to 1 bit */
// NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
//
// /* Configure the SPI interrupt priority */
// NVIC_InitStructure.NVIC_IRQChannel = BSP_SPIx_IRQn;
// NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
// NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
// NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
// NVIC_Init(&NVIC_InitStructure);
/* Master board configuration */
/* Initializes the SPI communication */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
SPI_Init(BSP_SPIx, &SPI_InitStructure);
//Debug_ShowRegister( SPI2_BASE, (DebugPeripheralTypedef *)&DeBugSPI );
/* Enable the SPI peripheral */
SPI_Cmd(BSP_SPIx, ENABLE);
/* The Data transfer is performed in the SPI interrupt routine */
/* Initialize Buffer counters */
ubTxIndex = 0;
ubRxIndex = 0;
/* Enable the Rx buffer not empty interrupt */
SPI_I2S_ITConfig(BSP_SPIx, SPI_I2S_IT_RXNE, ENABLE);
//Debug_ShowRegister( SPI2_BASE, (DebugPeripheralTypedef *)&DeBugSPI );
/* Enable the Tx buffer empty interrupt */
SPI_I2S_ITConfig(BSP_SPIx, SPI_I2S_IT_TXE, ENABLE);
}
void spi_init() {
// clear variables
memset(&spi_vars,0,sizeof(spi_vars_t));
SPI_InitTypeDef SPI_InitStructure;
//enable SPI1, GPIOA, GPIOB and GPIOC, Clock
RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);
RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC, ENABLE);
//Configure SPI-related pins: PA.5 as SCLK pin ,PA.6 as MISO pin, PA.7 as MOSI pin, PA.4 as /SEL pin
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOA, &GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
GPIO_Init(GPIOC, &GPIO_InitStructure);
// force reset
RESET_CLR();
CSn_SET();
SLEEP_CLR();
for (uint16_t j=0;j<0xFFFF;j++); //small wait
RESET_SET();
//Configure SPI1
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //Full-duplex synchronous transfers on two lines
SPI_InitStructure.SPI_Mode = SPI_Mode_Master;//Master Mode
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; //8-bit transfer frame format
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low; //the SCK pin has a low-level idle state
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge; //the first rising edge on the SCK pin is the MSBit capture strobe,
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;//Software NSS mode
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;//BaudRate Prescaler = 8
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;//data order with MSB-first
SPI_InitStructure.SPI_CRCPolynomial = 7;//CRC Polynomial = 7
SPI_Init(SPI1, &SPI_InitStructure);
//enable SPI1
SPI_Cmd(SPI1, ENABLE);
#ifdef SPI_IN_INTERRUPT_MODE
//Configure NVIC: Preemption Priority = 1 and Sub Priority = 1
NVIC_InitTypeDef NVIC_InitStructure;
NVIC_InitStructure.NVIC_IRQChannel = SPI1_IRQChannel;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
#endif
}
