STM32F0 ve RDID RC522, SPI ile haberleşme

[kkeess]

stm32f0 ve rc522 rfid kartını SPI ile haberleştirmeye çalışıyorum. f4 ve f1 için yazılmış kodlar buldum f0 kütüphanede gerekli değişimleri yaptım ama RFİD okuma yapmıyor. SPI ayarlarında F4'ten farklı olarak bi ayar mı vardır acaba? Kodlar aşağıdaki gibidir.

SPI Kütüphanesi
-----------------------------------------------------
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_rcc.h"
#include "stm32f0xx_misc.h"
#include "stm32f0xx_spi.h"
#include "stm32f0xx_tim.h"
#include "stm32f0xx_usart.h"
#include "rc522.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "SPI.h"
#include "tim2_delay.h"


/* SPI1 Enable */
void SPI1_Config(void)
{
	SPI_InitTypeDef SPI1_InitStructure;

	SPI1_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
	SPI1_InitStructure.SPI_Mode = SPI_Mode_Master;
	SPI1_InitStructure.SPI_DataSize = SPI_DataSize_8b;
	SPI1_InitStructure.SPI_CPOL = SPI_CPOL_Low;
	SPI1_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
	SPI1_InitStructure.SPI_NSS =SPI_NSS_Soft;
	SPI1_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
	SPI1_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
	SPI1_InitStructure.SPI_CRCPolynomial = 7;
	SPI_Init(SPI1,&SPI1_InitStructure);


	SPI_SSOutputCmd(SPI1,ENABLE);
	SPI_Cmd(SPI1,ENABLE);

	//-----------------------------------------------------------------------


} /* SPI1 Config Bitis */
uint8_t SPI1_SendByte(uint8_t data)
    {
	while (!(SPI1->SR & SPI_SR_TXE));
	SPI1->DR=data;
	while (!(SPI1->SR & SPI_SR_RXNE));
	return SPI1->DR;
}
void SPI1_WriteReg(uint8_t address, uint8_t value) {
	SPI1_NSS_ON();										// CS_Low
	SPI1_SendByte(address);
	SPI1_SendByte(value);
	SPI1_NSS_OFF();										// CS_HIGH
}

uint8_t SPI1_ReadReg(uint8_t address) {
	uint8_t	val;

	SPI1_NSS_ON();										// CS_Low
	SPI1_SendByte(address);
	val = SPI1_SendByte(0x00);
	SPI1_NSS_OFF();										// CS_HIGH
	return val;
}

Main
---------------------------------------------------
#include "stm32f0xx_gpio.h"
#include "stm32f0xx_rcc.h"
#include "stm32f0xx_misc.h"
#include "stm32f0xx_spi.h"
#include "stm32f0xx_tim.h"
#include "stm32f0xx_usart.h"
#include "rc522.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "SPI.h"
#include "tim2_delay.h";
#include "stdint.h"

#define SPI1_NSS_ON() GPIO_ResetBits(GPIOC,GPIO_Pin_0)
#define SPI1_NSS_OFF() GPIO_SetBits(GPIOC,GPIO_Pin_0)
#define led_1_ON() GPIO_SetBits(GPIOC,GPIO_Pin_8)
#define led_1_OFF() GPIO_ResetBits(GPIOC,GPIO_Pin_8)
#define led_2_ON() GPIO_SetBits(GPIOC,GPIO_Pin_9)
#define led_2_OFF() GPIO_ResetBits(GPIOC,GPIO_Pin_9)




#define RX_BUF_SIZE 80
volatile char RX_FLAG_END_LINE = 0;
volatile char RXi;
volatile char RXc;
volatile char RX_BUF[RX_BUF_SIZE] = {'\0'};
volatile char buffer[50];


void RCC_Config(void);
void GPIO_Config(void);
void USART1_Config(void);
void USART1_IRQHandler(void);
void clear_RXBuffer(void);
void SPI1_Config(void);

uint8_t CardID[5];

int main(void)
{
TIM2_init();
RCC_Config();
GPIO_Config();
USART1_Config();
SPI1_Config();
TIM2_init();
SPI1_NSS_OFF();
MFRC522_Init();
SPI1_NSS_OFF();
led_1_ON();
delay_ms(100);

USARTSend("Hello\n");
char a="asd";


    while(1)
    {
    	if(MFRC522_Check(CardID)==MI_OK)
    	{

    		led_2_OFF();
    		sprintf(buffer, "0x%02x\n0x%02x\n0x%02x\n0x%02x\n0x%02x", CardID[0], CardID[1], CardID[2], CardID[3], CardID[4]);
    		USARTSend(buffer);
    		char a="asd";

    	}
    	else if (MFRC522_Check(CardID)==MI_ERR);
    	{
    		led_2_ON();

    	}


}/* while bitis */


} /* Main bitis */

void RCC_Config(void)
{
	RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA|RCC_AHBPeriph_GPIOC,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1,ENABLE);
} /* RCC end */

void GPIO_Config(void)
{
	/* USART1 GPIO Config */
	GPIO_InitTypeDef USART1_Pin;

	USART1_Pin.GPIO_Mode = GPIO_Mode_AF;
	USART1_Pin.GPIO_Pin = GPIO_Pin_9|GPIO_Pin_10;
	USART1_Pin.GPIO_OType=GPIO_OType_PP;
	USART1_Pin.GPIO_PuPd = GPIO_PuPd_NOPULL;
	USART1_Pin.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&USART1_Pin);

	GPIO_PinAFConfig(GPIOA,GPIO_PinSource9,GPIO_AF_1);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource10,GPIO_AF_1);

	/* SPI1 GPIO Connfig */
	GPIO_InitTypeDef SPI1_Pin;

	SPI1_Pin.GPIO_Mode = GPIO_Mode_AF;
	SPI1_Pin.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;
	SPI1_Pin.GPIO_OType = GPIO_OType_PP;
	SPI1_Pin.GPIO_PuPd =GPIO_PuPd_NOPULL;
	SPI1_Pin.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&SPI1_Pin);

	GPIO_PinAFConfig(GPIOA,GPIO_PinSource5,GPIO_AF_0);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource6,GPIO_AF_0);
	GPIO_PinAFConfig(GPIOA,GPIO_PinSource7,GPIO_AF_0);

	/* LED ve SS/CS pin Config*/
	GPIO_InitTypeDef LED;

	LED.GPIO_Mode = GPIO_Mode_OUT;
	LED.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_8|GPIO_Pin_9;
	LED.GPIO_OType = GPIO_OType_PP;
	LED.GPIO_PuPd = GPIO_PuPd_NOPULL;
	LED.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOC,&LED);

	LED.GPIO_Mode = GPIO_Mode_OUT;
	LED.GPIO_Pin = GPIO_Pin_4;
	LED.GPIO_OType = GPIO_OType_PP;
	LED.GPIO_PuPd = GPIO_PuPd_NOPULL;
	LED.GPIO_Speed = GPIO_Speed_50MHz;
	GPIO_Init(GPIOA,&LED);

} /* GPIO END*/

void USART1_Config(void)
{
	NVIC_InitTypeDef NVIC_InitStructure;

	/* Enable Usart Interupt*/
	NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
	NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
	NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
	NVIC_Init(&NVIC_InitStructure);

	USART_InitTypeDef USART1_InitStructure;

	/*ENABLE Usart1*/
	USART1_InitStructure.USART_BaudRate = 9600;
	USART1_InitStructure.USART_Mode = USART_Mode_Rx|USART_Mode_Tx;
	USART1_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
	USART1_InitStructure.USART_Parity = USART_Parity_No;
	USART1_InitStructure.USART_StopBits = USART_StopBits_1;
	USART1_InitStructure.USART_WordLength = USART_WordLength_8b;
	USART_Init(USART1,&USART1_InitStructure);

	/* Enable Usart1 */
	USART_Cmd(USART1,ENABLE);

	/* Enable USART1 Receive interrupt */
	USART_ITConfig(USART1,USART_IT_RXNE,ENABLE);

} /* USART1 END*/

void USART1_IRQHandler(void)
{
	if((USART1->ISR & USART_FLAG_RXNE)!= RESET)
	{
		RXc=USART_ReceiveData(USART1);
		RX_BUF[RXi]= RXc;
		RXi++;

		USART_SendData(USART1,RXc);
	}

} /* USART1 Kesme Bitis */

void USARTSend(char *pucBuffer)
{
    while (*pucBuffer)
    {
        USART_SendData(USART1, *pucBuffer++);
        while(USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET)
        {
        }
    }
}

void clear_RXBuffer(void)
{
	for (RXi=0; RXi<RX_BUF_SIZE; RXi++)
		RX_BUF[RXi] = '\0';
	RXi = 0;
}
----------------------------------------------------------------
RC522 Kütüphanesi
---------------------------------------------------------------
// Mifare RC522 RFID Card reader 13.56 MHz
// STM32F103 RFID RC522 SPI1

// PA4  - (OUT)	SPI1_NSS
// PA5  - (OUT)	SPI1_SCK
// PA6  - (IN)	SPI1_MISO (Master In)
// PA7  - (OUT)	SPI1_MOSI (Master Out)

// MFRC522		STM32F103	DESCRIPTION
// CS (SDA)		PA4			SPI1_NSS	Chip select for SPI
// SCK			PA5			SPI1_SCK	Serial Clock for SPI
// MOSI			PA7 		SPI1_MOSI	Master In Slave Out for SPI
// MISO			PA6			SPI1_MISO	Master Out Slave In for SPI
// IRQ			-			Irq
// GND			GND			Ground
// RST			3.3V		Reset pin (3.3V)
// VCC			3.3V		3.3V power

#include "stm32f0xx_gpio.h"
#include "stm32f0xx_rcc.h"
#include "stm32f0xx_misc.h"
#include "stm32f0xx_spi.h"
#include "stm32f0xx_tim.h"
#include "stm32f0xx_usart.h"
#include "rc522.h"
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "SPI.h"
#include "tim2_delay.h";
#include "stdint.h"

void MFRC522_Init(void) {
	MFRC522_Reset();
	SPI1_NSS_OFF();
	MFRC522_WriteRegister(MFRC522_REG_T_MODE, 0x8D);
	MFRC522_WriteRegister(MFRC522_REG_T_PRESCALER, 0x3E);
	MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_L, 30);
	MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_H, 0);
	//MFRC522_WriteRegister(MFRC522_REG_RF_CFG, 0x70);			// 48dB gain
	MFRC522_WriteRegister(MFRC522_REG_TX_AUTO, 0x40);
	MFRC522_WriteRegister(MFRC522_REG_MODE, 0x3D);
	MFRC522_AntennaOn();										// Open the antenna
}

uint8_t MFRC522_Check(uint8_t * id) {
	uint8_t status;
	status = MFRC522_Request(PICC_REQIDL, id);					// Find cards, return card type
	if (status == MI_OK) status = MFRC522_Anticoll(id);			// Card detected. Anti-collision, return card serial number 4 bytes
	MFRC522_Halt();												// Command card into hibernation
	return status;
}

uint8_t MFRC522_Compare(uint8_t * CardID, uint8_t * CompareID) {
	uint8_t i;
	for (i = 0; i < 5; i++) {
		if (CardID[i] != CompareID[i]) return MI_ERR;
	}
	return MI_OK;
}

void MFRC522_WriteRegister(uint8_t addr, uint8_t val) {
	addr = (addr << 1) & 0x7E;																		// Address format: 0XXXXXX0
    SPI1_WriteReg(addr, val);
}

uint8_t MFRC522_ReadRegister(uint8_t addr) {
	uint8_t val;

	addr = ((addr << 1) & 0x7E) | 0x80;
	val = SPI1_ReadReg(addr);
	return val;
}

void MFRC522_SetBitMask(uint8_t reg, uint8_t mask) {
	MFRC522_WriteRegister(reg, MFRC522_ReadRegister(reg) | mask);
}

void MFRC522_ClearBitMask(uint8_t reg, uint8_t mask){
	MFRC522_WriteRegister(reg, MFRC522_ReadRegister(reg) & (~mask));
}

void MFRC522_AntennaOn(void) {
	uint8_t temp;

	temp = MFRC522_ReadRegister(MFRC522_REG_TX_CONTROL);
	if (!(temp & 0x03)) MFRC522_SetBitMask(MFRC522_REG_TX_CONTROL, 0x03);
}

void MFRC522_AntennaOff(void) {
	MFRC522_ClearBitMask(MFRC522_REG_TX_CONTROL, 0x03);
}

void MFRC522_Reset(void) {
	MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_RESETPHASE);
}

uint8_t MFRC522_Request(uint8_t reqMode, uint8_t * TagType) {
	uint8_t status;
	uint16_t backBits;																				// The received data bits

	MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING, 0x07);											// TxLastBists = BitFramingReg[2..0]
	TagType[0] = reqMode;
	status = MFRC522_ToCard(PCD_TRANSCEIVE, TagType, 1, TagType, &backBits);
	if ((status != MI_OK) || (backBits != 0x10)) status = MI_ERR;
	return status;
}

uint8_t MFRC522_ToCard(uint8_t command, uint8_t * sendData, uint8_t sendLen, uint8_t * backData, uint16_t * backLen) {
	uint8_t status = MI_ERR;
	uint8_t irqEn = 0x00;
	uint8_t waitIRq = 0x00;
	uint8_t lastBits;
	uint8_t n;
	uint16_t i;

	switch (command) {
		case PCD_AUTHENT: {
			irqEn = 0x12;
			waitIRq = 0x10;
			break;
		}
		case PCD_TRANSCEIVE: {
			irqEn = 0x77;
			waitIRq = 0x30;
			break;
		}
		default:
		break;
	}

	MFRC522_WriteRegister(MFRC522_REG_COMM_IE_N, irqEn | 0x80);
	MFRC522_ClearBitMask(MFRC522_REG_COMM_IRQ, 0x80);
	MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL, 0x80);
	MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_IDLE);

	// Writing data to the FIFO
	for (i = 0; i < sendLen; i++) MFRC522_WriteRegister(MFRC522_REG_FIFO_DATA, sendData[i]);

	// Execute the command
	MFRC522_WriteRegister(MFRC522_REG_COMMAND, command);
	if (command == PCD_TRANSCEIVE) MFRC522_SetBitMask(MFRC522_REG_BIT_FRAMING, 0x80);					// StartSend=1,transmission of data starts

	// Waiting to receive data to complete
	i = 2000;	// i according to the clock frequency adjustment, the operator M1 card maximum waiting time 25ms
	do {
		// CommIrqReg[7..0]
		// Set1 TxIRq RxIRq IdleIRq HiAlerIRq LoAlertIRq ErrIRq TimerIRq
		n = MFRC522_ReadRegister(MFRC522_REG_COMM_IRQ);
		i--;
	} while ((i!=0) && !(n&0x01) && !(n&waitIRq));

	MFRC522_ClearBitMask(MFRC522_REG_BIT_FRAMING, 0x80);												// StartSend=0

	if (i != 0)  {
		if (!(MFRC522_ReadRegister(MFRC522_REG_ERROR) & 0x1B)) {
			status = MI_OK;
			if (n & irqEn & 0x01) status = MI_NOTAGERR;
			if (command == PCD_TRANSCEIVE) {
				n = MFRC522_ReadRegister(MFRC522_REG_FIFO_LEVEL);
				lastBits = MFRC522_ReadRegister(MFRC522_REG_CONTROL) & 0x07;
				if (lastBits) *backLen = (n - 1) * 8 + lastBits; else *backLen = n * 8;
				if (n == 0) n = 1;
				if (n > MFRC522_MAX_LEN) n = MFRC522_MAX_LEN;
				for (i = 0; i < n; i++) backData[i] = MFRC522_ReadRegister(MFRC522_REG_FIFO_DATA);		// Reading the received data in FIFO
			}
		} else status = MI_ERR;
	}
	return status;
}

uint8_t MFRC522_Anticoll(uint8_t * serNum) {
	uint8_t status;
	uint8_t i;
	uint8_t serNumCheck = 0;
	uint16_t unLen;

	MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING, 0x00);												// TxLastBists = BitFramingReg[2..0]
	serNum[0] = PICC_ANTICOLL;
	serNum[1] = 0x20;
	status = MFRC522_ToCard(PCD_TRANSCEIVE, serNum, 2, serNum, &unLen);
	if (status == MI_OK) {
		// Check card serial number
		for (i = 0; i < 4; i++) serNumCheck ^= serNum[i];
		if (serNumCheck != serNum[i]) status = MI_ERR;
	}
	return status;
}

void MFRC522_CalculateCRC(uint8_t *  pIndata, uint8_t len, uint8_t * pOutData) {
	uint8_t i, n;

	MFRC522_ClearBitMask(MFRC522_REG_DIV_IRQ, 0x04);													// CRCIrq = 0
	MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL, 0x80);													// Clear the FIFO pointer
	// Write_MFRC522(CommandReg, PCD_IDLE);

	// Writing data to the FIFO
	for (i = 0; i < len; i++) MFRC522_WriteRegister(MFRC522_REG_FIFO_DATA, *(pIndata+i));
	MFRC522_WriteRegister(MFRC522_REG_COMMAND, PCD_CALCCRC);

	// Wait CRC calculation is complete
	i = 0xFF;
	do {
		n = MFRC522_ReadRegister(MFRC522_REG_DIV_IRQ);
		i--;
	} while ((i!=0) && !(n&0x04));																		// CRCIrq = 1

	// Read CRC calculation result
	pOutData[0] = MFRC522_ReadRegister(MFRC522_REG_CRC_RESULT_L);
	pOutData[1] = MFRC522_ReadRegister(MFRC522_REG_CRC_RESULT_M);
}

uint8_t MFRC522_SelectTag(uint8_t * serNum) {
	uint8_t i;
	uint8_t status;
	uint8_t size;
	uint16_t recvBits;
	uint8_t buffer[9];

	buffer[0] = PICC_SElECTTAG;
	buffer[1] = 0x70;
	for (i = 0; i < 5; i++) buffer[i+2] = *(serNum+i);
	MFRC522_CalculateCRC(buffer, 7, &buffer[7]);		//??
	status = MFRC522_ToCard(PCD_TRANSCEIVE, buffer, 9, buffer, &recvBits);
	if ((status == MI_OK) && (recvBits == 0x18)) size = buffer[0]; else size = 0;
	return size;
}

uint8_t MFRC522_Auth(uint8_t authMode, uint8_t BlockAddr, uint8_t * Sectorkey, uint8_t * serNum) {
	uint8_t status;
	uint16_t recvBits;
	uint8_t i;
	uint8_t buff[12];

	// Verify the command block address + sector + password + card serial number
	buff[0] = authMode;
	buff[1] = BlockAddr;
	for (i = 0; i < 6; i++) buff[i+2] = *(Sectorkey+i);
	for (i=0; i<4; i++) buff[i+8] = *(serNum+i);
	status = MFRC522_ToCard(PCD_AUTHENT, buff, 12, buff, &recvBits);
	if ((status != MI_OK) || (!(MFRC522_ReadRegister(MFRC522_REG_STATUS2) & 0x08))) status = MI_ERR;
	return status;
}

uint8_t MFRC522_Read(uint8_t blockAddr, uint8_t * recvData) {
	uint8_t status;
	uint16_t unLen;

	recvData[0] = PICC_READ;
	recvData[1] = blockAddr;
	MFRC522_CalculateCRC(recvData,2, &recvData[2]);
	status = MFRC522_ToCard(PCD_TRANSCEIVE, recvData, 4, recvData, &unLen);
	if ((status != MI_OK) || (unLen != 0x90)) status = MI_ERR;
	return status;
}

uint8_t MFRC522_Write(uint8_t blockAddr, uint8_t * writeData) {
	uint8_t status;
	uint16_t recvBits;
	uint8_t i;
	uint8_t buff[18];

	buff[0] = PICC_WRITE;
	buff[1] = blockAddr;
	MFRC522_CalculateCRC(buff, 2, &buff[2]);
	status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &recvBits);
	if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)) status = MI_ERR;
	if (status == MI_OK) {
		// Data to the FIFO write 16Byte
		for (i = 0; i < 16; i++) buff[i] = *(writeData+i);
		MFRC522_CalculateCRC(buff, 16, &buff[16]);
		status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 18, buff, &recvBits);
		if ((status != MI_OK) || (recvBits != 4) || ((buff[0] & 0x0F) != 0x0A)) status = MI_ERR;
	}
	return status;
}

void MFRC522_Halt(void)
{
	uint16_t unLen;
	uint8_t buff[4];

	buff[0] = PICC_HALT;
	buff[1] = 0;
	MFRC522_CalculateCRC(buff, 2, &buff[2]);
	MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff, &unLen);
}