26 Eylül 2018, 01:43:02

Haberler:

Eposta uyarılarını yanıtlamayınız ( ! ) https://bit.ly/2J7yi0d


aynı 2 kütüphaneyi işlemcide kullanabilmek

Başlatan görkem, 08 Kasım 2017, 00:44:12

görkem

Arkadaşlar Merhaba,

2 ayrı donanımsal  spi ile haberleşen modüllerim var. Bu modüllerin kütüphanelerini nasıl tanımlayabilirim. 1 tanesini tanımlarken sıkıntı yok 2. modül için tanımlamaya kalktığımda nasıl bir yol izlemeliyim kütüphanenin ismini ve fiziksel pinlerin tanımlarını değiştirmek yeterli olurmu?

İyi Çalışmalar. 

baran123

Olur da ona gerek yok ki.
Bu kütüphaneyi çoklu SPI için yapsan daha iyi olur.
Mesela şöyle
Kod Seç

typedef enum
{
   
SPI1 0,
   
SPI2
}SPI_t;


#define SPI1_MOSI ...


void SPI_Init(SPI_t SPIx)
{
   if (
SPIx == SPI1)
   {
   }
}



Bu mantığı read/write ve diğer fonksiyonlar içinde yaparsan olur.
İdrak i meali bu küçük akla gerekmez, zira bu terazi bu kadar sıkleti çekmez.

görkem

çoklu spi yaptığımda diğer fonksiyonlara dokunmasam direk fiziksel spi pinleri ni read write fonksiyonlarını ve init fonksiyonunu  revizyon yapsam kütüphanede sorun yaşarmıyım komple revizyona ihtiyaç olurmu vaktim fazla olmadığı için soruyorum

baran123

Yanı çakışan bir şey yok ise olur.
Fakat kodu paylaşırsan bir örnek verebilirim.
İdrak i meali bu küçük akla gerekmez, zira bu terazi bu kadar sıkleti çekmez.

görkem


kullandığım kütüphane aşağıda

header

Kod Seç

#ifndef MFRC522_H
#define MFRC522_H 

#include "stm32f1xx_hal.h"                  // Device header
#include "stm32f1xx_hal_gpio.h"
#include "stm32f1xx_hal_spi.h"

extern SPI_HandleTypeDef hspi1;


typedef enum {
   
MI_OK 0,
   
MI_NOTAGERR,
   
MI_ERR
MFRC522_Status_t;

#define MFRC522_CS_LOW              HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_RESET);
#define MFRC522_CS_HIGH             HAL_GPIO_WritePin(GPIOA,GPIO_PIN_4,GPIO_PIN_SET);

/* MFRC522 Commands */
#define PCD_IDLE                  0x00   //NO action; Cancel the current command
#define PCD_AUTHENT                  0x0E   //Authentication Key
#define PCD_RECEIVE                  0x08   //Receive Data
#define PCD_TRANSMIT               0x04   //Transmit data
#define PCD_TRANSCEIVE               0x0C   //Transmit and receive data,
#define PCD_RESETPHASE               0x0F   //Reset
#define PCD_CALCCRC                  0x03   //CRC Calculate

/* Mifare_One card command word */
#define PICC_REQIDL                  0x26   // find the antenna area does not enter hibernation
#define PICC_REQALL                  0x52   // find all the cards antenna area
#define PICC_ANTICOLL               0x93   // anti-collision
#define PICC_SElECTTAG               0x93   // election card
#define PICC_AUTHENT1A               0x60   // authentication key A
#define PICC_AUTHENT1B               0x61   // authentication key B
#define PICC_READ                  0x30   // Read Block
#define PICC_WRITE                  0xA0   // write block
#define PICC_DECREMENT               0xC0   // debit
#define PICC_INCREMENT               0xC1   // recharge
#define PICC_RESTORE               0xC2   // transfer block data to the buffer
#define PICC_TRANSFER               0xB0   // save the data in the buffer
#define PICC_HALT                  0x50   // Sleep

/* MFRC522 Registers */
//Page 0: Command and Status
#define MFRC522_REG_RESERVED00         0x00    
#define MFRC522_REG_COMMAND            0x01    
#define MFRC522_REG_COMM_IE_N         0x02    
#define MFRC522_REG_DIV1_EN            0x03    
#define MFRC522_REG_COMM_IRQ         0x04    
#define MFRC522_REG_DIV_IRQ            0x05
#define MFRC522_REG_ERROR            0x06    
#define MFRC522_REG_STATUS1            0x07    
#define MFRC522_REG_STATUS2            0x08    
#define MFRC522_REG_FIFO_DATA         0x09
#define MFRC522_REG_FIFO_LEVEL         0x0A
#define MFRC522_REG_WATER_LEVEL         0x0B
#define MFRC522_REG_CONTROL            0x0C
#define MFRC522_REG_BIT_FRAMING         0x0D
#define MFRC522_REG_COLL            0x0E
#define MFRC522_REG_RESERVED01         0x0F
//Page 1: Command 
#define MFRC522_REG_RESERVED10         0x10
#define MFRC522_REG_MODE            0x11
#define MFRC522_REG_TX_MODE            0x12
#define MFRC522_REG_RX_MODE            0x13
#define MFRC522_REG_TX_CONTROL         0x14
#define MFRC522_REG_TX_AUTO            0x15
#define MFRC522_REG_TX_SELL            0x16
#define MFRC522_REG_RX_SELL            0x17
#define MFRC522_REG_RX_THRESHOLD      0x18
#define MFRC522_REG_DEMOD            0x19
#define MFRC522_REG_RESERVED11         0x1A
#define MFRC522_REG_RESERVED12         0x1B
#define MFRC522_REG_MIFARE            0x1C
#define MFRC522_REG_RESERVED13         0x1D
#define MFRC522_REG_RESERVED14         0x1E
#define MFRC522_REG_SERIALSPEED         0x1F
//Page 2: CFG    
#define MFRC522_REG_RESERVED20         0x20  
#define MFRC522_REG_CRC_RESULT_M      0x21
#define MFRC522_REG_CRC_RESULT_L      0x22
#define MFRC522_REG_RESERVED21         0x23
#define MFRC522_REG_MOD_WIDTH         0x24
#define MFRC522_REG_RESERVED22         0x25
#define MFRC522_REG_RF_CFG            0x26
#define MFRC522_REG_GS_N            0x27
#define MFRC522_REG_CWGS_PREG         0x28
#define MFRC522_REG__MODGS_PREG         0x29
#define MFRC522_REG_T_MODE            0x2A
#define MFRC522_REG_T_PRESCALER         0x2B
#define MFRC522_REG_T_RELOAD_H         0x2C
#define MFRC522_REG_T_RELOAD_L         0x2D
#define MFRC522_REG_T_COUNTER_VALUE_H   0x2E
#define MFRC522_REG_T_COUNTER_VALUE_L   0x2F
//Page 3:TestRegister 
#define MFRC522_REG_RESERVED30         0x30
#define MFRC522_REG_TEST_SEL1         0x31
#define MFRC522_REG_TEST_SEL2         0x32
#define MFRC522_REG_TEST_PIN_EN         0x33
#define MFRC522_REG_TEST_PIN_VALUE      0x34
#define MFRC522_REG_TEST_BUS         0x35
#define MFRC522_REG_AUTO_TEST         0x36
#define MFRC522_REG_VERSION            0x37
#define MFRC522_REG_ANALOG_TEST         0x38
#define MFRC522_REG_TEST_ADC1         0x39  
#define MFRC522_REG_TEST_ADC2         0x3A   
#define MFRC522_REG_TEST_ADC0         0x3B   
#define MFRC522_REG_RESERVED31         0x3C   
#define MFRC522_REG_RESERVED32         0x3D
#define MFRC522_REG_RESERVED33         0x3E   
#define MFRC522_REG_RESERVED34         0x3F
//Dummy byte
#define MFRC522_DUMMY               0x00

#define MFRC522_MAX_LEN               16

/**
 * Public functions
 */
/**
 * Initialize MFRC522 RFID reader
 *
 * Prepare MFRC522 to work with RFIDs
 *
 */
extern void MFRC522_Init(void);

/**
 * Check for RFID card existance
 *
 * Parameters:
 *    - uint8_t* id:
 *       Pointer to 5bytes long memory to store valid card id in.
 *       ID is valid only if card is detected, so when function returns MI_OK
 *
 * Returns MI_OK if card is detected
 */
extern MFRC522_Status_t MFRC522_Check(uint8_tid);

/**
 * Compare 2 RFID ID's
 * Useful if you have known ID (database with allowed IDs), to compare detected card with with your ID
 *
 * Parameters:
 *    - uint8_t* CardID:
 *       Pointer to 5bytes detected card ID
 *    - uint8_t* CompareID:
 *       Pointer to 5bytes your ID
 *
 * Returns MI_OK if IDs are the same, or MI_ERR if not
 */
extern MFRC522_Status_t MFRC522_Compare(uint8_tCardIDuint8_tCompareID);

/**
 * Private functions
 */
extern void MFRC522_InitPins(void);
extern void MFRC522_WriteRegister(uint8_t addruint8_t val);
extern uint8_t MFRC522_ReadRegister(uint8_t addr);
extern void MFRC522_SetBitMask(uint8_t reguint8_t mask);
extern void MFRC522_ClearBitMask(uint8_t reguint8_t mask);
extern void MFRC522_AntennaOn(void);
extern void MFRC522_AntennaOff(void);
extern void MFRC522_Reset(void);
extern MFRC522_Status_t MFRC522_Request(uint8_t reqModeuint8_tTagType);
extern MFRC522_Status_t MFRC522_ToCard(uint8_t commanduint8_tsendDatauint8_t sendLenuint8_tbackDatauint16_tbackLen);
extern MFRC522_Status_t MFRC522_Anticoll(uint8_tserNum);
extern void MFRC522_CalculateCRC(uint8_tpIndatauint8_t lenuint8_tpOutData);
extern uint8_t MFRC522_SelectTag(uint8_tserNum);
extern MFRC522_Status_t MFRC522_Auth(uint8_t authModeuint8_t BlockAddruint8_tSectorkeyuint8_tserNum);
extern MFRC522_Status_t MFRC522_Read(uint8_t blockAddruint8_trecvData);
extern MFRC522_Status_t MFRC522_Write(uint8_t blockAddruint8_twriteData);
extern void MFRC522_Halt(void);

#endif




source

Kod Seç


#include "mfrc522.h"





void MFRC522_Init(void) {
MFRC522_CS_HIGH;


   
MFRC522_Reset();

   
MFRC522_WriteRegister(MFRC522_REG_T_MODE0x8D);
   
MFRC522_WriteRegister(MFRC522_REG_T_PRESCALER0x3E);
   
MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_L30);           
   
MFRC522_WriteRegister(MFRC522_REG_T_RELOAD_H0);

   
/* 48dB gain */
   
MFRC522_WriteRegister(MFRC522_REG_RF_CFG0x70);
   
   
MFRC522_WriteRegister(MFRC522_REG_TX_AUTO0x40);
   
MFRC522_WriteRegister(MFRC522_REG_MODE0x3D);

   
MFRC522_AntennaOn();      //Open the antenna
}



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

   
return status;
}

MFRC522_Status_t MFRC522_Compare(uint8_tCardIDuint8_tCompareID) {
   
uint8_t i;
	

	

   for (
04i++) {
	
	
 
CompareID[i]=CardID[i];
      if (
CardID[i] != CompareID[i]) {
         break;
      } return 
MI_ERR;
	
	
}
   
   return 
MI_OK;
}


   

   


void MFRC522_WriteRegister(uint8_t addruint8_t val) {
   
//CS low
   
MFRC522_CS_LOW;
   
//Send address
	
addr=addr << 1;
	
addr=addr 0x7E;
	

   
HAL_SPI_Transmit(&hspi1,&addr,1,500);
   
//Send data   
   
HAL_SPI_Transmit(&hspi1,&val,1,500);
   
//CS high
   
MFRC522_CS_HIGH;
}

uint8_t MFRC522_ReadRegister(uint8_t addr){
   
uint8_t val;
   
//CS low
   
MFRC522_CS_LOW;
addr=addr << 1;
	
addr=addr 0x7E;
	
addr=addr 0x80;
   
HAL_SPI_Transmit(&hspi1,&addr,1,500);  
	

   
HAL_SPI_Transmit(&hspi1,MFRC522_DUMMY,1,500);
	

	

   
HAL_SPI_Receive(&hspi1,&val,1,500);
   
//CS high
   
MFRC522_CS_HIGH;

   return 
val;   
}

void MFRC522_SetBitMask(uint8_t reguint8_t mask) {
   
MFRC522_WriteRegister(regMFRC522_ReadRegister(reg) | mask);
}

void MFRC522_ClearBitMask(uint8_t reguint8_t mask){
   
MFRC522_WriteRegister(regMFRC522_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_CONTROL0x03);
   }
}

void MFRC522_AntennaOff(void) {
   
MFRC522_ClearBitMask(MFRC522_REG_TX_CONTROL0x03);
}

void MFRC522_Reset(void) {
   
MFRC522_WriteRegister(MFRC522_REG_COMMANDPCD_RESETPHASE);
}

MFRC522_Status_t MFRC522_Request(uint8_t reqModeuint8_tTagType) {
   
MFRC522_Status_t status;  
   
uint16_t backBits;         //The received data bits

   
MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING0x07);      //TxLastBists = BitFramingReg[2..0]   ???

   
TagType[0] = reqMode;
   
status MFRC522_ToCard(PCD_TRANSCEIVETagType1TagType, &backBits);

   if ((
status != MI_OK) || (backBits != 0x10)) {    
      
status MI_ERR;
   }

   return 
status;
}

MFRC522_Status_t MFRC522_ToCard(uint8_t commanduint8_tsendDatauint8_t sendLenuint8_tbackDatauint16_tbackLen) {
   
MFRC522_Status_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_NirqEn 0x80);
   
MFRC522_ClearBitMask(MFRC522_REG_COMM_IRQ0x80);
   
MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL0x80);

   
MFRC522_WriteRegister(MFRC522_REG_COMMANDPCD_IDLE);

   
//Writing data to the FIFO
   
for (0sendLeni++) {   
      
MFRC522_WriteRegister(MFRC522_REG_FIFO_DATAsendData[i]);    
   }

   
//Execute the command
   
MFRC522_WriteRegister(MFRC522_REG_COMMANDcommand);
   if (
command == PCD_TRANSCEIVE) {    
      
MFRC522_SetBitMask(MFRC522_REG_BIT_FRAMING0x80);      //StartSend=1,transmission of data starts  
   
}   

   
//Waiting to receive data to complete
   
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
      
MFRC522_ReadRegister(MFRC522_REG_COMM_IRQ);
      
i--;
   } while ((
i!=0) && !(n&0x01) && !(n&waitIRq));

   
MFRC522_ClearBitMask(MFRC522_REG_BIT_FRAMING0x80);         //StartSend=0

   
if (!= 0)  {
      if (!(
MFRC522_ReadRegister(MFRC522_REG_ERROR) & 0x1B)) {
         
status MI_OK;
         if (
irqEn 0x01) {   
            
status MI_NOTAGERR;         
         }

         if (
command == PCD_TRANSCEIVE) {
            
MFRC522_ReadRegister(MFRC522_REG_FIFO_LEVEL);
            
lastBits MFRC522_ReadRegister(MFRC522_REG_CONTROL) & 0x07;
            if (
lastBits) {   
               *
backLen = (1) * lastBits;   
            } else {   
               *
backLen 8;   
            }

            if (
== 0) {   
               
1;    
            }
            if (
MFRC522_MAX_LEN) {   
               
MFRC522_MAX_LEN;   
            }

            
//Reading the received data in FIFO
            
for (0ni++) {   
               
backData[i] = MFRC522_ReadRegister(MFRC522_REG_FIFO_DATA);    
            }
         }
      } else {   
         
status MI_ERR;  
      }
   }

   return 
status;
}

MFRC522_Status_t MFRC522_Anticoll(uint8_tserNum) {
   
MFRC522_Status_t status;
   
uint8_t i;
   
uint8_t serNumCheck 0;
   
uint16_t unLen;

   
MFRC522_WriteRegister(MFRC522_REG_BIT_FRAMING0x00);      //TxLastBists = BitFramingReg[2..0]

   
serNum[0] = PICC_ANTICOLL;
   
serNum[1] = 0x20;
   
status MFRC522_ToCard(PCD_TRANSCEIVEserNum2serNum, &unLen);
//(uint8_t command, uint8_t* sendData, uint8_t sendLen, uint8_t* backData, uint16_t* backLen) {
   
if (status == MI_OK) {
      
//Check card serial number
      
for (04i++) {   
         
serNumCheck ^= serNum[i];
      }
      if (
serNumCheck != serNum[i]) {   
         
status MI_ERR;    
      }
   }
   return 
status;


void MFRC522_CalculateCRC(uint8_t*  pIndatauint8_t lenuint8_tpOutData) {
   
uint8_t in;

   
MFRC522_ClearBitMask(MFRC522_REG_DIV_IRQ0x04);         //CRCIrq = 0
   
MFRC522_SetBitMask(MFRC522_REG_FIFO_LEVEL0x80);         //Clear the FIFO pointer
   //Write_MFRC522(CommandReg, PCD_IDLE);

   //Writing data to the FIFO   
   
for (0leni++) {   
      
MFRC522_WriteRegister(MFRC522_REG_FIFO_DATA, *(pIndata+i));   
   }
   
MFRC522_WriteRegister(MFRC522_REG_COMMANDPCD_CALCCRC);

   
//Wait CRC calculation is complete
   
0xFF;
   do {
      
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_tserNum) {
   
uint8_t i;
   
MFRC522_Status_t status;
   
uint8_t size;
   
uint16_t recvBits;
   
uint8_t buffer[9]; 

   
buffer[0] = PICC_SElECTTAG;
   
buffer[1] = 0x70;
   for (
05i++) {
      
buffer[i+2] = *(serNum+i);
   }
   
MFRC522_CalculateCRC(buffer7, &buffer[7]);      //??
   
status MFRC522_ToCard(PCD_TRANSCEIVEbuffer9buffer, &recvBits);

   if ((
status == MI_OK) && (recvBits == 0x18)) {   
      
size buffer[0]; 
   } else {   
      
size 0;    
   }

   return 
size;
}

MFRC522_Status_t MFRC522_Auth(uint8_t authModeuint8_t BlockAddruint8_tSectorkeyuint8_tserNum) {
   
MFRC522_Status_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 (
06i++) {    
      
buff[i+2] = *(Sectorkey+i);   
   }
   for (
i=0i<4i++) {    
      
buff[i+8] = *(serNum+i);   
   }
   
status MFRC522_ToCard(PCD_AUTHENTbuff12buff, &recvBits);

   if ((
status != MI_OK) || (!(MFRC522_ReadRegister(MFRC522_REG_STATUS2) & 0x08))) {   
      
status MI_ERR;   
   }
   return 
status;
}

MFRC522_Status_t MFRC522_Read(uint8_t blockAddruint8_trecvData) {
   
MFRC522_Status_t status;
   
uint16_t unLen;

   
recvData[0] = PICC_READ;
   
recvData[1] = blockAddr;
   
MFRC522_CalculateCRC(recvData,2, &recvData[2]);
   
status MFRC522_ToCard(PCD_TRANSCEIVErecvData4recvData, &unLen);

   if ((
status != MI_OK) || (unLen != 0x90)) {
      
status MI_ERR;
   }

   return 
status;
}

MFRC522_Status_t MFRC522_Write(uint8_t blockAddruint8_twriteData) {
   
MFRC522_Status_t status;
   
uint16_t recvBits;
   
uint8_t i;
   
uint8_t buff[18]; 

   
buff[0] = PICC_WRITE;
   
buff[1] = blockAddr;
   
MFRC522_CalculateCRC(buff2, &buff[2]);
   
status MFRC522_ToCard(PCD_TRANSCEIVEbuff4buff, &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 (016i++) {    
         
buff[i] = *(writeData+i);   
      }
      
MFRC522_CalculateCRC(buff16, &buff[16]);
      
status MFRC522_ToCard(PCD_TRANSCEIVEbuff18buff, &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(buff2, &buff[2]);

   
MFRC522_ToCard(PCD_TRANSCEIVEbuff4buff, &unLen);
}



baran123

tamam işte kütüphanede problem yok ama ufak düzenleme yapman gerek.
Dediğim gibi fonksiyonlara parametre olarak SPIx ver.
Örneğin :

MFRC522_WriteRegister(SPI1, MFRC522_REG_T_RELOAD_H, 0);

İdrak i meali bu küçük akla gerekmez, zira bu terazi bu kadar sıkleti çekmez.

furkanyx

Once C programlamada birden çok dosya ile calismayi ogrensen zorlanmazsin bu kadar. Hatta fonksiyon kavraminj falan en bastan ogren. Cunku temel kavramlari bilmeden bodoslama atlarsan kafan karisir. Once high level da test et kodlarini sonrasi basit zaten.

görkem

bu durumla ilk defa karşılaştığım için sıkıntı yaşamıştım çözümü çok basitmiş hallettim teşekkür ederim.