1. Kernel Config:
set CONFIG_TIMER_STATS=y Collect kernel timers statistics. can use /proc/timer_stats

2. Using Linux interval timer

3. Accessing SPI

4. Accessing I2C

reference:
[1]. https://elinux.org/Kernel_Timer_Systems
[2]. https://forum.armbian.com/topic/1901-patch-for-quick-interrupt-handling-on-the-h3-fast-gpio/
[3]. https://xilinx-wiki.atlassian.net/wiki/spaces/A/pages/18842191/Linux+GIC+Driver, the documentation of linux interrupt controller
[4]. http://cs.brown.edu/courses/csci1680/s22/content/threads2.pdf

---

TODO:
# Isolating CPUs Using tuned's isolated_cores Option

The initial mechanism for isolating CPUs is specifying the boot parameter isolcpus=cpulist
use [cat /proc/cmdline] to see the boot argument

https://forum.armbian.com/topic/12922-how-can-i-set-isolated-cpu-on-orange-pi-zero/

https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux_for_real_time/7/html/tuning_guide/isolating_cpus_using_tuned-profiles-realtime

https://forum.armbian.com/topic/1901-patch-for-quick-interrupt-handling-on-the-h3-fast-gpio/

https://forum.armbian.com/topic/1885-rt-patches-for-sun8i-kernel/

# https://0xax.gitbooks.io/linux-insides/content/Timers/linux-timers-4.html
# https://xilinx-wiki.atlassian.net/wiki/spaces/A/pages/18842191/Linux+GIC+Driver, the documentation of linux interrupt controller
# https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux_for_real_time/7/html/reference_guide/chap-hardware_interrupts

# https://www.kernel.org/doc/html/v4.14/driver-api/spi.html, SPI programming

# setitimer

# SPI

https://github.com/azorg/spi/blob/master/spi.c

# I2C

https://elinux.org/Interfacing_with_I2C_Devices

3,980 total views, 6 views today

The post WIP: Linux Timer Interrupt appeared first on HE Qichen's Hackspace.

话说2018年春节的时候，3d打印了一个机械臂。

还是老样子，在纸上先画一个机械臂大概的形状

在CAD中画出具体参数，看看用什么养的配置比较合适，作业半径会是多少。 

确定参数就可以开始做三维建模。

一步一步开始搭建机械臂的每个部分。

底座

第一关节

第二关节

第三关节，上面可以安装夹具

所有的配件就是这些

机械手臂上当然是要有手了 XD

用机械手来帮你选一瓶饮料

还是再切一个合适的手给机械臂

当然机械臂也可以很欢乐

7,024 total views, 2 views today

The post 3D打印机械臂 appeared first on HE Qichen's Hackspace.

先随手在纸上画一下看看最终会长成什么样。  

 然后就可以在3D软件里面开始画，首先画个球 >.<

然后把它搞成蛋状。尺寸就按照刚刚随手画的图来

再在边上画个环

把它移到正确的位置上，表示夹住纸的空缺部分。

切出放纸的凹槽

同样把下半部分蛋去掉

简简单单的纸夹就画好了，送去打印。

开始打印

完成

这样scrum card可以放在纸夹上面，提醒最主要的事情是什么。

         完~

5,548 total views, 1 views today

The post 自制纸夹 | 3D 打印 appeared first on HE Qichen's Hackspace.

既然键盘是USB接口的，有了USB hub就可以在键盘里面藏更多的东西，真正变成geek的利器。

在键盘上找到VCC GND USB_D+ USB_D-，看上去C8应该是个滤波电容，两边应该就是vcc 和 gnd了，用飞飞线把USB引到hub上。键盘原本的USB就不能在继续使用了，必须封掉

随便找来一根USB线，用这根线作为键盘的数据线了，原本GH60的设计是从键盘的上方出线，但这个脑残的设计让键盘使用十分不方便，键盘前方必须留出距离走线，而我习惯是从侧面，也就是左边出线，因为右侧是要鼠标的地方。

夹好杜邦头，这样以后维修起来就方便了。

找到合适的位置打孔，可以让USB线从中间穿过。

大致就是这样，因为还要加USB设备，所以先用难看的纸胶带临时固定一下。

显然只在键盘里放USB hub是不够的，下面就是最近发现性价比极高的pcm2704

之所以找到pcm2704是因为前段时间用笔记本放音乐的时候一直有讨厌的噪音，播放钢琴的时候特别明显特别讨厌，所以想找找有没有适合的外置DAC，后来找了一圈之后发现Pcm2704实在是太好了，便宜又好用。

把同样把DAC接到HUB上。

同样找到合适的位置掏洞，把耳机插口露出来，后来发现GH60壳体实在太厚，手头有没有外置式的3.5耳机接口 T.T

只能把洞掏的无比巨大。。

固定好DAC，今天就可以到这里了。

上好螺丝，打完收工 

在键盘里面藏个USB hub的可玩性太高了，以后外出就不必要鼠标键盘都往电脑上插，直接一把键盘搞定。

同时，也想过在键盘里面放nanopi 或着BBB，一把键盘走天下了。

7,143 total views, 1 views today

The post GH60 折腾之三 | GH60 hacks part3 appeared first on HE Qichen's Hackspace.

话说刚收到GH60 PCB的时候，看到上面印着一个s开头的网址，十分欣喜。虽然淘宝的页面上面没有任何刷机教程，没有任何的连接，但是至少这东西有个官网在，应该可以找到资料。然而，看到后缀是.cn的，顿时心凉了一半。。这个不是国外的个人作品么，怎么有中文的网址，难道是国内的抄袭板？别抄一半改一半啊。

果不其然，上了网站没有找到任何有用的信息。。无奈开始谷歌。

其实，网上能找到很多在网页上配置配列，然后可以直接下载固件的做法，但是都无法做到鼠标的控制，backspace分开，shift分开。

最终找到了kairyu在github上的代码，终于能够使用了，我fork在了我自己的repo里面，方便自己开发。

我的代码地址：

https://github.com/heqichen/tmk_keyboard_custom

https://github.com/heqichen/tmk_core_custom

修改的地方主要在 tmk_keyboard_custom 这个项目当中。

1. tmk_keyboard_custom/keyboard/gh60/keymap_heqichen.c

增加了这个文件，这个文件中是我自己的配列。代码中定义的HHKB可以在keymap_common.h里面找到，kairyu中的HHKB定义是有bug的是有bug的是有bug的。。我一个一个对下来才发现错在哪里。。。

2. tmk_keyboard_custom/keyboard/gh60/Makefile

增加了以下两行

REV = CHN
KEYMAP = heqichen

CHN的作用就是指定这是GH60的中国版，KEYMAP指定了我的键盘配列，会自动找到keymap_heqichen.c去编译。

其实网上很多做法在make命令后面根这两个参数也是可以的，只是我比较懒，把他们直接写到了makefile里面。

经过这番折腾，终于把GH60用起来了。

现在的问题是

1. 鼠标的移动不是平滑连续的，而是一卡一卡像按键一样，这点nano75要做的好很多。

2. 现在GH60没有办法控制音量，包括audio想相关HID命令和Volume的相关HID命令都没有办法执行。

有时间我把这些问题解决掉。

10,840 total views, 2 views today

The post GH60 折腾之二 | GH60 Hacks Part2 appeared first on HE Qichen's Hackspace.

所以新的键盘一定是完全可编程的，这次就更加激进的选择了没有F区域的键盘。

淘宝上选了一圈，最终选择了s开头的一款 PCB。用了五脚青轴。

焊接到没遇到什么困难，只是把按钮插进去的时候实在是麻烦。PCB上的安装孔实在太小，把按钮往里查的时候相当于硬把塑料挂掉一层，按得我手指抽筋，最终没办法，把所有的安装孔都用电钻扩了一遍。但是这样的结果就是，没有量好塑料支撑脚的直径，PCB上的安装孔扩了太大了，无脚变成了三脚-_-。。。受力只靠两个焊点，按钮就有些摇晃，正常情况下就需要用定位板来解决摇晃的问题，但是没有买定位板。只能将就了。

 配列上选择了把backspace一分为二，把右shift再分多一个键的方案。

最终装好之后发现塑料外壳没有撑脚，键盘的角度太低，打字不舒服。

网上找来这些仪器撑脚装在了塑料壳上

选择好合适的位置打孔。

装完支撑脚，用起来舒服多了。

至于颜色-_-

我自己也看不下去了。。。在买键帽的店里选择了R4的四个键帽，结果发过来的是R1的。。。无奈，我也不想再和店家沟通，再其他店买了两个R4的键帽装了上去，颜色就变成了现在这样

给键盘刷配置也是恨这疼的过程，明天继续。。。

3,940 total views, no views today

The post GH60折腾 | GH60 hacks appeared first on HE Qichen's Hackspace.

第一季6期的荣誉之战终于杀青了，从夏天拍到了冬天。

看看导播室里的工作场景。

刚刚停电恢复，好几个摄像机还是黑屏。

为了游戏的需要，连夜修改程序。

看到一个通信的大家伙，就是天线比较粗，比较长。

屏幕上显示了一些射频的参数，不知道是发送什么。

5,106 total views, no views today

The post 荣誉之战 appeared first on HE Qichen's Hackspace.

对战场地正在布置中

导播室

导播室的装备 

帅气的教官

在双方大本营准备上战场的装备

演员马上就要到啦

沫沫和甜甜

许教官

小臭和孙铭

蓝队布置战术

金波在导播室压阵

导播室的幕后英雄阿杜，控制所有战场的进程和数据。

团队合照，真心感谢兄弟们

6,854 total views, 3 views today

The post 又拍电视了-荣誉之战 第一季第一集 appeared first on HE Qichen's Hackspace.

盼了好几天，终于盼来了送NanoPI的快递，打开一看发现一个小盒子。顿时眼前一亮。

小盒子的外观像是一本日记本，而不是一般买开发板仅仅见到一个自封袋或者时白色的纸盒包装，国产神器顿时高大上了。

看看背面，印有NanoPi的相关参数

打开在扉页里面印着pinmap，方便查阅引脚功能。

轻轻拿起装有NanoPi的包装。整个盒子里没有说明书，介绍全部印在了包装盒上面，相当简约。

仔细看看NanoPi 现在就要给NanoPi刷上系统了 ：-D

4,725 total views, no views today

The post NanoPI 开箱 appeared first on HE Qichen's Hackspace.

为了造一套门禁系统，淘宝上搞来了一套RFID读卡器。

RC522，看上去是比较多的型号，哪家店都买得到。

本来想拔整个模块装进一个接线盒里，但是这尺寸刚刚好，如果放进去就没法盖盖子了。。。无奈，先裸奔。

Youtube连接：https://www.youtube.com/watch?v=4yIT7Gunn6c

也是网上找来的代码

 

#include <SPI.h>

#define uchar unsigned char
#define uint unsigned int

//data array maxium length
#define MAX_LEN 16

/////////////////////////////////////////////////////////////////////
//set the pin
/////////////////////////////////////////////////////////////////////
const int chipSelectPin = 10;
const int NRSTPD = 5;

 

//MF522 command bits
#define PCD_IDLE 0x00 //NO action; cancel current commands
#define PCD_AUTHENT 0x0E //verify password key
#define PCD_RECEIVE 0x08 //receive data
#define PCD_TRANSMIT 0x04 //send data
#define PCD_TRANSCEIVE 0x0C //send and receive data
#define PCD_RESETPHASE 0x0F //reset
#define PCD_CALCCRC 0x03 //CRC check and caculation

//Mifare_One card command bits
#define PICC_REQIDL 0x26 //Search the cards that not into sleep mode in the antenna area
#define PICC_REQALL 0x52 //Search all the cards in the antenna area
#define PICC_ANTICOLL 0x93 //prevent conflict
#define PICC_SElECTTAG 0x93 //select card
#define PICC_AUTHENT1A 0x60 //verify A password key
#define PICC_AUTHENT1B 0x61 //verify B password key
#define PICC_READ 0x30 //read
#define PICC_WRITE 0xA0 //write
#define PICC_DECREMENT 0xC0 //deduct value
#define PICC_INCREMENT 0xC1 //charge up value
#define PICC_RESTORE 0xC2 //Restore data into buffer
#define PICC_TRANSFER 0xB0 //Save data into buffer
#define PICC_HALT 0x50 //sleep mode
//THe mistake code that return when communicate with MF522
#define MI_OK 0
#define MI_NOTAGERR 1
#define MI_ERR 2
//------------------MFRC522 register ---------------
//Page 0:Command and Status
#define Reserved00 0x00
#define CommandReg 0x01
#define CommIEnReg 0x02
#define DivlEnReg 0x03
#define CommIrqReg 0x04
#define DivIrqReg 0x05
#define ErrorReg 0x06
#define Status1Reg 0x07
#define Status2Reg 0x08
#define FIFODataReg 0x09
#define FIFOLevelReg 0x0A
#define WaterLevelReg 0x0B
#define ControlReg 0x0C
#define BitFramingReg 0x0D
#define CollReg 0x0E
#define Reserved01 0x0F
//Page 1:Command
#define Reserved10 0x10
#define ModeReg 0x11
#define TxModeReg 0x12
#define RxModeReg 0x13
#define TxControlReg 0x14
#define TxAutoReg 0x15
#define TxSelReg 0x16
#define RxSelReg 0x17
#define RxThresholdReg 0x18
#define DemodReg 0x19
#define Reserved11 0x1A
#define Reserved12 0x1B
#define MifareReg 0x1C
#define Reserved13 0x1D
#define Reserved14 0x1E
#define SerialSpeedReg 0x1F
//Page 2:CFG
#define Reserved20 0x20
#define CRCResultRegM 0x21
#define CRCResultRegL 0x22
#define Reserved21 0x23
#define ModWidthReg 0x24
#define Reserved22 0x25
#define RFCfgReg 0x26
#define GsNReg 0x27
#define CWGsPReg 0x28
#define ModGsPReg 0x29
#define TModeReg 0x2A
#define TPrescalerReg 0x2B
#define TReloadRegH 0x2C
#define TReloadRegL 0x2D
#define TCounterValueRegH 0x2E
#define TCounterValueRegL 0x2F
//Page 3:TestRegister
#define Reserved30 0x30
#define TestSel1Reg 0x31
#define TestSel2Reg 0x32
#define TestPinEnReg 0x33
#define TestPinValueReg 0x34
#define TestBusReg 0x35
#define AutoTestReg 0x36
#define VersionReg 0x37
#define AnalogTestReg 0x38
#define TestDAC1Reg 0x39
#define TestDAC2Reg 0x3A
#define TestADCReg 0x3B
#define Reserved31 0x3C
#define Reserved32 0x3D
#define Reserved33 0x3E
#define Reserved34 0x3F
//-----------------------------------------------

//4 bytes Serial number of card, the 5 bytes is verfiy bytes
uchar serNum[5];

int AUTHED_ID_NUM = 8;

unsigned char AUTHED_ID_LIST[][4] =
{
{0x72, 0xBB, 0x7C, 0x6F},
{0xF1, 0x6D, 0xB3, 0x85},
{0x09, 0x11, 0x8F, 0x87},
{0xCF, 0x9C, 0x24, 0x71},
{0x88, 0x04, 0xBF, 0xC5},
{0x88, 0x04, 0x5D, 0x9E},
{0x88, 0x04, 0xF6, 0x8A},
{0x88, 0x99, 0xA5, 0xCA}
};

char *AUTHED_NAME_LIST[] =
{
"key-chain",
"white-card",
"Shanghai-transport",
"Beijing-transport",
"Guangzhou-Metro",
"Shenzhen-Metro",
"train-ticket #1",
"train-ticket #2"
};

 

void setup()
{
Serial.begin(57600);

SPI.begin();

pinMode(chipSelectPin,OUTPUT); // Set digital pin 10 as OUTPUT to connect it to the RFID /ENABLE pin
digitalWrite(chipSelectPin, LOW); // Activate the RFID reader
pinMode(NRSTPD,OUTPUT); // Set digital pin 5 , Not Reset and Power-down

MFRC522_Init();

pinMode(4, OUTPUT);
digitalWrite(4, LOW);
}

void showCardDetail()
{

uchar status;
uchar str[MAX_LEN];
// Show card type
ShowCardType(str);

//Prevent conflict, return the 4 bytes Serial number of the card
status = MFRC522_Anticoll(str);

// str[0..3]: serial number of the card
// str[4]: XOR checksum of the SN.
if (status == MI_OK)
{
Serial.print("The card's number is: ");
memcpy(serNum, str, 5);
ShowCardID(serNum);

// Check people associated with card ID
uchar* id = serNum;
if( id[0]==0x4B && id[1]==0xE6 && id[2]==0xD1 && id[3]==0x3B ) {
Serial.println("Hello Mary!");
} else if(id[0]==0x3B && id[1]==0xE6 && id[2]==0xD1 && id[3]==0x3B) {
Serial.println("Hello Greg!");
}else{
Serial.println("Hello unkown guy!");
}
}

}

unsigned long lastFoundTime = 0;
int lastFoundCard = -1;

void loop()
{

uchar status;
uchar str[MAX_LEN];
// Search card, return card types
status = MFRC522_Request(PICC_REQIDL, str);
if (status != MI_OK)
{
return;
}

//showCardDetail();
status = MFRC522_Anticoll(str);
if (status == MI_OK)
{
memcpy(serNum, str, 5);
uchar* id = serNum;
int authedId = findInAuthedList(id);
if (authedId >= 0)
{
if (lastFoundCard != authedId || (millis() - lastFoundTime) > 2000)
{
Serial.print("Card read: ");
Serial.println(AUTHED_NAME_LIST[authedId]);
lastFoundTime = millis();
digitalWrite(4, HIGH);
delay(50);
digitalWrite(4, LOW);
}

}
else
{
Serial.print("unknown card found: ");
ShowCardID(serNum);
}
lastFoundCard = authedId;
}

MFRC522_Halt(); //command the card into sleep mode

delay(200);
}

int findInAuthedList(uchar *id)
{
int i;
int j;
for (i=0; i<AUTHED_ID_NUM; ++i)
{
for (j=0; j<4; ++j)
{
if (AUTHED_ID_LIST[i][j] != id[j])
{
break;
}
}
if(j >= 4)
{
return i;
}
}
return -1;
}

/*
* Function：ShowCardID
* Description：Show Card ID
* Input parameter：ID string
* Return：Null
*/
void ShowCardID(uchar *id)
{
int IDlen=4;
for(int i=0; i<IDlen; i++){
Serial.print(0x0F & (id[i]>>4), HEX);
Serial.print(0x0F & id[i],HEX);
}
Serial.println("");
}

/*
* Function：ShowCardType
* Description：Show Card type
* Input parameter：Type string
* Return：Null
*/
void ShowCardType(uchar* type)
{
Serial.print("Card type: ");
if(type[0]==0x04&&type[1]==0x00)
Serial.println("MFOne-S50");
else if(type[0]==0x02&&type[1]==0x00)
Serial.println("MFOne-S70");
else if(type[0]==0x44&&type[1]==0x00)
Serial.println("MF-UltraLight");
else if(type[0]==0x08&&type[1]==0x00)
Serial.println("MF-Pro");
else if(type[0]==0x44&&type[1]==0x03)
Serial.println("MF Desire");
else
Serial.println("Unknown");
}

/*
* Function：Write_MFRC5200
* Description：write a byte data into one register of MR RC522
* Input parameter：addr--register address；val--the value that need to write in
* Return：Null
*/
void Write_MFRC522(uchar addr, uchar val)
{
digitalWrite(chipSelectPin, LOW);

//address format：0XXXXXX0
SPI.transfer((addr<<1)&0x7E);
SPI.transfer(val);

digitalWrite(chipSelectPin, HIGH);
}
/*
* Function：Read_MFRC522
* Description：read a byte data into one register of MR RC522
* Input parameter：addr--register address
* Return：return the read value
*/
uchar Read_MFRC522(uchar addr)
{
uchar val;

digitalWrite(chipSelectPin, LOW);

//address format：1XXXXXX0
SPI.transfer(((addr<<1)&0x7E) | 0x80);
val =SPI.transfer(0x00);

digitalWrite(chipSelectPin, HIGH);

return val;
}

/*
* Function：SetBitMask
* Description：set RC522 register bit
* Input parameter：reg--register address;mask--value
* Return：null
*/
void SetBitMask(uchar reg, uchar mask)
{
uchar tmp;
tmp = Read_MFRC522(reg);
Write_MFRC522(reg, tmp | mask); // set bit mask
}
/*
* Function：ClearBitMask
* Description：clear RC522 register bit
* Input parameter：reg--register address;mask--value
* Return：null
*/
void ClearBitMask(uchar reg, uchar mask)
{
uchar tmp;
tmp = Read_MFRC522(reg);
Write_MFRC522(reg, tmp & (~mask)); // clear bit mask
}
/*
* Function：AntennaOn
* Description：Turn on antenna, every time turn on or shut down antenna need at least 1ms delay
* Input parameter：null
* Return：null
*/
void AntennaOn(void)
{
uchar temp;

temp = Read_MFRC522(TxControlReg);
if (!(temp & 0x03))
{
SetBitMask(TxControlReg, 0x03);
}
}
/*
* Function：AntennaOff
* Description：Turn off antenna, every time turn on or shut down antenna need at least 1ms delay
* Input parameter：null
* Return：null
*/
void AntennaOff(void)
{
ClearBitMask(TxControlReg, 0x03);
}
/*
* Function：ResetMFRC522
* Description： reset RC522
* Input parameter：null
* Return：null
*/
void MFRC522_Reset(void)
{
Write_MFRC522(CommandReg, PCD_RESETPHASE);
}
/*
* Function：InitMFRC522
* Description：initilize RC522
* Input parameter：null
* Return：null
*/
void MFRC522_Init(void)
{
digitalWrite(NRSTPD,HIGH);

MFRC522_Reset();

//Timer: TPrescaler*TreloadVal/6.78MHz = 24ms
Write_MFRC522(TModeReg, 0x8D); //Tauto=1; f(Timer) = 6.78MHz/TPreScaler
Write_MFRC522(TPrescalerReg, 0x3E); //TModeReg[3..0] + TPrescalerReg
Write_MFRC522(TReloadRegL, 30);
Write_MFRC522(TReloadRegH, 0);

Write_MFRC522(TxAutoReg, 0x40); //100%ASK
Write_MFRC522(ModeReg, 0x3D); //CRC initilizate value 0x6363 ???

//ClearBitMask(Status2Reg, 0x08); //MFCrypto1On=0
//Write_MFRC522(RxSelReg, 0x86); //RxWait = RxSelReg[5..0]
//Write_MFRC522(RFCfgReg, 0x7F); //RxGain = 48dB

AntennaOn(); //turn on antenna
}
/*
* Function：MFRC522_Request
* Description：Searching card, read card type
* Input parameter：reqMode--search methods，
* TagType--return card types
* 0x4400 = Mifare_UltraLight
* 0x0400 = Mifare_One(S50)
* 0x0200 = Mifare_One(S70)
* 0x0800 = Mifare_Pro(X)
* 0x4403 = Mifare_DESFire
* return：return MI_OK if successed
*/
uchar MFRC522_Request(uchar reqMode, uchar *TagType)
{
uchar status;
uint backBits; //the data bits that received

Write_MFRC522(BitFramingReg, 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;
}
/*
* Function：MFRC522_ToCard
* Description：communicate between RC522 and ISO14443
* Input parameter：command--MF522 command bits
* sendData--send data to card via rc522
* sendLen--send data length
* backData--the return data from card
* backLen--the length of return data
* return：return MI_OK if successed
*/
uchar MFRC522_ToCard(uchar command, uchar *sendData, uchar sendLen, uchar *backData, uint *backLen)
{
uchar status = MI_ERR;
uchar irqEn = 0x00;
uchar waitIRq = 0x00;
uchar lastBits;
uchar n;
uint i;

switch (command)
{
case PCD_AUTHENT: //verify card password
{
irqEn = 0x12;
waitIRq = 0x10;
break;
}
case PCD_TRANSCEIVE: //send data in the FIFO
{
irqEn = 0x77;
waitIRq = 0x30;
break;
}
default:
break;
}

Write_MFRC522(CommIEnReg, irqEn|0x80); //Allow interruption
ClearBitMask(CommIrqReg, 0x80); //Clear all the interrupt bits
SetBitMask(FIFOLevelReg, 0x80); //FlushBuffer=1, FIFO initilizate

Write_MFRC522(CommandReg, PCD_IDLE); //NO action;cancel current command ???

//write data into FIFO
for (i=0; i<sendLen; i++)
{
Write_MFRC522(FIFODataReg, sendData[i]);
}

//procceed it
Write_MFRC522(CommandReg, command);
if (command == PCD_TRANSCEIVE)
{
SetBitMask(BitFramingReg, 0x80); //StartSend=1,transmission of data starts
}

//waite receive data is finished
i = 2000; //i should adjust according the clock, the maxium the waiting time should be 25 ms???
do
{
//CommIrqReg[7..0]
//Set1 TxIRq RxIRq IdleIRq HiAlerIRq LoAlertIRq ErrIRq TimerIRq
n = Read_MFRC522(CommIrqReg);
i--;
}
while ((i!=0) && !(n&0x01) && !(n&waitIRq));

ClearBitMask(BitFramingReg, 0x80); //StartSend=0

if (i != 0)
{
if(!(Read_MFRC522(ErrorReg) & 0x1B)) //BufferOvfl Collerr CRCErr ProtecolErr
{
status = MI_OK;
if (n & irqEn & 0x01)
{
status = MI_NOTAGERR; //??
}

if (command == PCD_TRANSCEIVE)
{
n = Read_MFRC522(FIFOLevelReg);
lastBits = Read_MFRC522(ControlReg) & 0x07;
if (lastBits)
{
*backLen = (n-1)*8 + lastBits;
}
else
{
*backLen = n*8;
}

if (n == 0)
{
n = 1;
}
if (n > MAX_LEN)
{
n = MAX_LEN;
}

//read the data from FIFO
for (i=0; i<n; i++)
{
backData[i] = Read_MFRC522(FIFODataReg);
}
}
}
else
{
status = MI_ERR;
}

}

//SetBitMask(ControlReg,0x80); //timer stops
//Write_MFRC522(CommandReg, PCD_IDLE);

return status;
}
/*
* Function：MFRC522_Anticoll
* Description：Prevent conflict, read the card serial number
* Input parameter：serNum--return the 4 bytes card serial number, the 5th byte is recheck byte
* return：return MI_OK if successed
*/
uchar MFRC522_Anticoll(uchar *serNum)
{
uchar status;
uchar i;
uchar serNumCheck=0;
uint unLen;

//ClearBitMask(Status2Reg, 0x08); //strSensclear
//ClearBitMask(CollReg,0x80); //ValuesAfterColl
Write_MFRC522(BitFramingReg, 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)
{
//Verify card serial number
for (i=0; i<4; i++)
{
serNumCheck ^= serNum[i];
}
if (serNumCheck != serNum[i])
{
status = MI_ERR;
}
}

//SetBitMask(CollReg, 0x80); //ValuesAfterColl=1

return status;
}
/*
* Function：CalulateCRC
* Description：Use MF522 to caculate CRC
* Input parameter：pIndata--the CRC data need to be read，len--data length，pOutData-- the caculated result of CRC
* return：Null
*/
void CalulateCRC(uchar *pIndata, uchar len, uchar *pOutData)
{
uchar i, n;

ClearBitMask(DivIrqReg, 0x04); //CRCIrq = 0
SetBitMask(FIFOLevelReg, 0x80); //Clear FIFO pointer
//Write_MFRC522(CommandReg, PCD_IDLE);

//Write data into FIFO
for (i=0; i<len; i++)
{
Write_MFRC522(FIFODataReg, *(pIndata+i));
}
Write_MFRC522(CommandReg, PCD_CALCCRC);

//waite CRC caculation to finish
i = 0xFF;
do
{
n = Read_MFRC522(DivIrqReg);
i--;
}
while ((i!=0) && !(n&0x04)); //CRCIrq = 1

//read CRC caculation result
pOutData[0] = Read_MFRC522(CRCResultRegL);
pOutData[1] = Read_MFRC522(CRCResultRegM);
}

 

/*
* Function：MFRC522_Write
* Description：write block data
* Input parameters：blockAddr--block address;writeData--Write 16 bytes data into block
* return：return MI_OK if successed
*/
uchar MFRC522_Write(uchar blockAddr, uchar *writeData)
{
uchar status;
uint recvBits;
uchar i;
uchar buff[18];

buff[0] = PICC_WRITE;
buff[1] = blockAddr;
CalulateCRC(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)
{
for (i=0; i<16; i++) //Write 16 bytes data into FIFO
{
buff[i] = *(writeData+i);
}
CalulateCRC(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;
}
/*
* Function：MFRC522_Halt
* Description：Command the cards into sleep mode
* Input parameters：null
* return：null
*/
void MFRC522_Halt(void)
{
uchar status;
uint unLen;
uchar buff[4];

buff[0] = PICC_HALT;
buff[1] = 0;
CalulateCRC(buff, 2, &buff[2]);

status = MFRC522_ToCard(PCD_TRANSCEIVE, buff, 4, buff,&unLen);
}

6,633 total views, no views today

The post RC522读RFID卡 appeared first on HE Qichen's Hackspace.