RFID Bee Projects

USB NFC Reader

2011-11-14T17:33:00.000-08:00

USB NFC Reader

With its combination of a modern slim design and its state of the art multi-protocol feature set, SCL010 is the perfect desktop reader choice to support various contactless applications such as electronic ID, payment & public transportation schemes and to interact with NFC-enabled devices. As for all SCM Microsystems products, SCL010 is designed to offer best in class interoperability with various formats of tokens: cards, dongles, watches or NFC mobile phones.

Technical Information

Media Support:

Smart Card

Interfaces/Ports

Interfaces:

USB 2.0 USB

Physical Characteristics

Dimensions:

0.31" Height x 2.56" Width x 4.33" Length

Weight (Approximate):

2.47 oz

Official Name: SCM MICROSYSTEMS, INC.

Business Description: SCM Microsystems is a leading supplier of solutions that open the Digital World by enabling people to conveniently access digital content and services. The company develops, markets and sells the industry’s broadest range of smart card readers and terminal technology for secure PC, network and physical access and digital media readers for transfer of digital content to OEM customers in the government, financial, enterprise, consumer electronics, health care and photographic equipment markets worldwide.

Official Website: http://www.scmmicro.com

RFID To Barcode Project

2011-10-17T19:27:00.000-07:00

RFID To Barcode Project.

In This Project we want to use RFID tag to barcode system.

RFID to barcode project will received data form tag then change to TTL Barcode signal and RS-232 Option and PS/2 Option and USB Option.

เพื่อ ระบบนำ ระบบ RFID มาใช้ร่วมกับ ระบบ BARCODE ได้ โดยรับสัญญาณจาก RFID TAG โดย RFID Module แล้วนำมาแปลงเป็นสัญญาณ Barcode สัญญาณ Output ที่ออกมาจะเสมือนเป็น สัญญาณ Barcode ซึ่งสามารถนำไปใช้งานกับ Barcode เดิมได้ทันที

Specification

Technology : NXP Mifare Standard

Frequency : 13.56 MHz

ISO Std. : ISO14443A

TAG Support : Mifare ultralight, Mifare1K, Maifare 4K

Active Range : 10 cm. with built-in Antenna

Barcode Output : TTL 5 V.

PS/2 Connector Output

USB Type B Connector Output

RS-232 DB-9 pin Connector Output

Power Supply : 5V.DC.

Hardware

MCU : PIC18F4550 SMD TQFP-44

CLOCK : X’TAL 20MHz

IC MAX232CSE SMD SOIC-16

DIP SW 2 bit for select output port

2 LED Status

Feature

Can set key and Data Block to read. ( in picture show debug monitor port for RFID to Barcode port )

TTL output ( same barcode signal form barcode reader )

RS-232 Output

PS/2 Output

USB Output ( HID complaint So you can open Text edit software to read data such as MS word or Notepad )

UHF Long Range RFID

2011-09-19T21:59:00.000-07:00

MR6034E UHF RFID reader is base on generation 1（MR6034A）product improved generation 2 RFID reader，This reader compatible many protocol、separate type design、connect with 4 antenna、fast reading、multi tag identify、Industry protection grade design etc. This reader are widely use in various RFID system，reference application as below：

1. Logistics and warehouse Management: Goods flow, warehouse management, and the flowing management of mail, parcel, luggage.

2. Intelligent parking Management :Parking management and automatic charge

3. Productive lines Management: Production process fixed Identify

4. Product counterfeit-proof inspection: Using memory’s write-protect functions inside tags, and identifying with true-false of products

5. Other fields: Used widely in club management, library, student’s school, consumption management, time management, dinner management, pool management

Reader characteristic:

1. Special Anti collision algorithm, high efficient of multi-tag identify capability；

2. Four separate transmit/receive antenna to make more wide of area in the application；

3. Compatible ISO18000-6B and ISO18000-6C(EPC-GEN2) protocol standard；

4. Read/Write tag capability：read >12m, write is 60% of read reading（depend on different tag）；
5. Reader support multi tag identify、single tag read、tag write、lock、and Kill tag etc.

Technical parameters

Model	MR6034E
Protocol	ISO18000-6B，ISO18000-6C（EPC GEN2）
Frequency	Standard ISM 902～928MHz and ISM 865～868MHz, other frequency available
Operation Mode	FHSS
RF Power	0~30dBm，software programmable
Reading Speed	Software Programmable，Average Reading per 64Bits：<6ms
Reading Mode	Timing or Touch,Software Programmable
Data Ports	Standard: RS485，RS232，RJ45(TCP/IP）；software programmable
Output Port	4 Team outport (can control output high/low level)
Reading Range	Depends on antenna gain, when connect with 12dbi antenna, the reading distance is about 12m
Reading Clue	Buzzer and LED
Antenna	one~four Antenna, TNC connector
Power Supply	DC＋9V (supply AC/DC power adapter)
Dimension	310mm×210mm×40mm
Weight	2 .7Kg
Operation Temp	－20℃~＋80℃

OTR318 Handheld RFID Reader/Writer

2011-09-09T21:27:00.000-07:00

OTR318 Handheld RFID Reader/Writer

orangeTags is pleased to introduce the OTR318, a high frequency (13.56MHz) handheld reader/writer designed to address a wide array of HF applications including cashless payments, secure transactions, access control, product verification, and item level tracking in supply chain applications.

The OTR318 multi-protocol handheld RFID reader/writer has been cost effectively designed in a compact yet powerful form factor that is not only lightweight but also durable with a comfortable feel and stylish outlook.

OTR318 supports contact smart card protocol ISO 7816 and also secure, encrypted applications using ISO 14443 Type A/B.

Microprocessor	32-bit ARM RISC CPU32
Display	128x64 dot, EL backlight, 16x8 lines ASCII Characters (8x4 lines Chinese Characters)
Memory	FLASH Memory: 16Mbit (supports up to 64Mbits) DRAM: 16Mbit
Keyboard	16 keys with backlight. 1 Jog Dialer
Contact Interface	ISO7816 (8 pin full function) contact card interface. SAM Card Socket (optional). Compatible with T=0/T=1 protocol
Contactless Interface	13.56MHz (ISO 14443A & ISO 15693) Read Range: 20cm
Communication Interface	1 x RS232, 1 x IrDA
Add-on Options	•GPRS multislot class 10 DL:85.6kbps UL:42.8kbps • Barcode • Fingerprint
Batteries	850mAH Rechargable Lithium Battery
Operating Temperature	-20°C to +50°C
Operating Humidity	45%RH to 85%RH (non-condensing)
Operating Power	Average < 0.5W, Max < 3.5W
Dimensions	L154 x W67 x H30 mm
Weight	170g
Housing	ABS
Software Development Kit	OTR318 SDK.rar

ACR122L VisualVantage NFC Reader with LCD

2011-09-05T21:48:00.000-07:00

ACR122L VisualVantage NFC Reader with LCD

For richer user interaction in contactless applications

ACR122L is a serial interface NFC contactless reader with LCD. It is developed based on the 13.56 MHz RFID technology and the ISO/IEC 18092 NFC standard, and supports ISO 14443 Type A and B cards, Mifare, FeliCa and NFC technologies, including all 4 types of NFC tags and all 3 modes – reader, peer-to-peer and card emulation modes.

ACR122L is a plug-and-play device that does not require any driver installation. It comes with 4 LEDs, a buzzer and an LCD, which both provide users with a clear indication of the reader's status. The 2-line graphic LCD has multiple language support, including language support for Chinese, English, Japanese and some European languages. It allows interactive operation, such as scrolling up and down, left and right, etc. Moreover, it is equipped with three built-in SAM slots for enhanced security in contactless operations.

The reader can read and write more quickly and efficiently by using up to 424 Kbps of tag access. It also has a proximity operating distance of up to 50 mm, depending on the type of tag in use. Further, its built-in anti-collision feature and direct card type polling commands ensure a smooth operation, allowing the device to access only one card, even in cases where multiple cards are present and detectable.

Typical applications of ACR122L include e-payment, loyalty programs and access control.

ACR122L Standard Features:
· Serial RS232 Interface · 7V DC for power supply (UK plug adaptor by default and VDE plug on request) · CCID-like frame format (Binary format) · Built-in antenna for contactless tag access, with card reading distance of up to 50 mm (depending on tag type) · Support for ISO 14443 Part 4 Type A and B cards, Mifare, FeliCa and all 4 types of NFC (ISO/IEC 18092) tags · Support for new Mifare Ultralight C, Mifare Plus and DESFire EV1 · Support for all 3 modes of NFC: reader, card emulation and peer-to-peer modes · Builti-in anti-collision feature (only 1 tag is accessed at any time) · Selective card polling capability (especially useful when multiple cards are presented) · 2-line graphic LCD with interactive interoperability (scroll up and down, left and right, etc.) and multi-language support (Chinese, English, Japanese and some European languages) · Three ISO 7816-compliant SAM slots · Four User-controllable LEDs · User-controllable buzzer
Typical Applications:
· e-Government · e-Banking and e-Payment · e-Healthcare · Transportation · Network Security · Access Control · Loyalty Program
Technical Specifications:
Dimensions	Main Body: 136.66 mm (L) x 88.66 mm (W) x 19.00 mm (H); With Stand: 158.33 mm (L) x 95.00 mm (W) x 95.00 mm (H)
Weight	Main Body: 200 g; With Stand: 600 g
Interface	Serial RS232
Operating Distance	Up to 50 mm (depends on the tag type)
Supply Voltage	7V DC
Supply Current	200 mA (maximum); 50 mA (standby); 100 mA (normal)
Operating Temperature	0 - 50 °C
Compliance/Certifications	CE, FCC, VCCI, RoHS
Operating System Support	· Windows 98, ME, 2000, XP, Vista, 7, Server 2003, Server 2008, Server 2008 R2 · Windows CE 5.0 · Linux, Mac

ACR122 NFC Contactless Smart Card Reader

2011-09-05T21:41:00.000-07:00

ACR122 NFC Contactless Smart Card Reader
The World’s First NFC Card Reader compliant to CCID Standard

The ACR122 is a PC-linked Contacless Smart Card Reader/Writer developed on the 13.56MHz Contactless (RFID) Technology and followed the ISO/IEC18092 Standard for Near Field Communication (NFC), supporting not only Mifare®, ISO 14443 A and B cards but also NFC and FeliCa contactless technologies.

The ACR122 is a USB Plug and Play device with the CCID compliance. It is ideal for both secure personal identity verification and online micro-payment transactions. Typical applications of the ACR122 reader include access control, e-payment, e-ticketing for events and mass transit, toll road fare collection and network authentication.

By making use of up to 212 Kbps for NFC Tag access and full USB speed of up to 12 Mbps, the ACR122 can read and write faster and more efficiently. The proximity operating distance of ACR122 is up to 5 cm, depending on the type of contactless tag in use. An RF boaster can be added on customization requests to extend the distance.

In order to increase the security level, the ACR122 can be optionally integrated with an ISO7816-3 SAM slot. In addition, the ACR122 is available in module form for easy integration into bigger machines, like POS terminals, physical access devices and vending machines.

With excellent performance and flexibility, you can experience the convenience and benefits offered by the ACR122.

ACR122 reader standard features:
USB Full Speed (12 Mbps) USB PnP Bi-Color LED Built-in Antenna NFC Reader ISO/IEC18092 (NFC) compliant NFC Tags Access Speed = 212 kbps Contactless Smart Card Reader Support FeliCa card Support ISO 14443 Type A & B cards - MIFARE® cards (Classics, DESFire) CCID Standard CE and FCC Certificated RoHS Compliant User Controllable Buzzer (optional) SAM Socket (optional)
Typical applications:
Home Banking and Home Shopping E-commerce Checking the balance of electronic purses Network access control Customer Loyalty Program Identification and Authentication Ticketing Online gaming Parking and toll collection Automatic Fare Collection Public Transportation Terminals Physical Access Control Time attendance Vending machines Contactless public phones Logistics and supply chain management
Technical Specifications:
Dimensions	98 mm (L) x 65 mm (W) x 12.8 mm (H)
Weight	70 grams
Interface	USB Full Speed
Operating Distance	<= 50mm
Supply Voltage	Regulated 5V DC
Supply Current	200mA (operating); 50mA (standby); 100mA (normal)
Operating Temperature	0-50°C
Operating Frequency	13.56 MHz
Standards/Certifications	ISO14443 1-4, PC/SC, CE, FCC, RoHS Compliant
Operating System Support	Windows 2000, XP 32, XP64, Vista 32 and Vista 64

RFID Warehousing Logistics Management

2011-08-24T22:43:00.000-07:00

RFID Warehousing logistics management

System Introduction

Currently RFID technology is the area of the supply chain brought about a great change, to identify distance, rapid and difficult to damage, such as bar code capacity unmatched advantage, simplifying complex workflows, to effectively improve supply chain efficiency and transparency

Pallet supply chain are the most basic is the most important cargo units, it has been widely used in the production, warehousing, logistics and retail supply chain in all aspect. Shenzhen HUC Technology Co., Ltd. logistics flow pallet RFID solutions are designed for practical application of supply chain design

System Composition

Tray electronic tags, readers, antennas, mobile reading and writing equipment, management software Backgrounds

System Flow

A. Finished product storage boxes - with the electronic tag to enter the empty tray pallet entrance equipment by reading and writing of electronic tags to read and write tests to ensure that performance standards for the electronic tag to enter the circulation. Barcode scanning system for inspection of finished goods qualified me to sweep the bar code, fitted crib, reading and writing compressed will handle the entire cargo pallet barcode write electronic tag information, the implementation of bar code associated with the tag and information to a central management system

B. Aspect tray storage boxes to change or fragmented --- Terminals assembled using mobile RFID read-write device to adjust the data boxes after the re-associated with the tag, write the new tag information, update the central database synchronization

C. Tray out of the Treasury through the fixed RFID reader equipment and antennas buried electronic tag information collected and uploaded to a central management system, the system will verify the data extract barcode information to form boxes, and a dozen achieve two commercial arrival sweep scanning system docking

D. Distribution Center receiving tray in the reading area to stay 2-3 seconds to complete the entire cargo tray sweep of the code, without unstacking single sweep code re-loaded pile

4. System advantages

The program using passive electronic tag, long life, maintenance-free, unique design and can be embedded in a good quality plastic pallets, it is not easy in the tray during transport by collisions, wear and tear. In addition, the electronic tag rewritable data will help resolve the cargo tray adjust, assembled, such as warehousing and logistics questions, tags can be reused, saving the user significant cost

System achieve long-range identification, reading and writing fast and reliable, able to adapt to dynamic running conveyor belt to read and adapt to cigarette manufacturers and other industrial production environment (pieces of the smoke stack), has good anti-interference ability of metal, metal cigarette can be overcome foil packaging to identify the impact of RFID to meet the needs of modern logistics

Deal with information in the tags used in advanced data compression technology to enable electronic loading tray tags carry information (data packets), just scanning tray once the electronic tag information to understand items, remove the tray down tray and reload the necessary human material, to save time, reduce the error rate and probability of damage to goods, realize faster and more accurate inventory, improve the overall transparency of enterprise logistics

5. Effective implementation of the system

The program using long-distance RFID technology, has greatly improved the storage yard sweep speed and accuracy, improve the operating efficiency of the logistics to address the demolition trays, tray loading brought about by increased labor costs, on-site control problem difficulty. System in the logistics aspect of the successful application of the tobacco industry for the whole area of logistics application of RFID technology summed up the experience, laid the foundation, set a good example.

仓储物流管理

一、系统介绍

目前RFID技术正在为供应链领域带来一场巨大的变革，以识别距离远，快速，不易损坏，容量大等条码无法比拟的优势，简化繁杂的工作流程，有效改善供应链的效率和透明度。

托盘是供应链中最基础也是最主要的货物单元，它已经广泛应用于生产、仓储、物流、零售等各个供应链环节。深圳市创方科技有限有限公司的物流周转托盘RFID解决方案是专为供应链实际应用设计的。

二、系统组成

托盘电子标签，阅读器，天线，移动式读写设备，后台管理软件。

三、工作流程

(1)成品货箱入库——带电子标签的空托盘进入托盘入口，由读写设备对电子标签进行读写测试，保证性能达到标准的电子标签进入流通环节。条码扫描系统对检验合格的成品货箱上的条码进行扫码，装垛，读写器将经过压缩处理的整个托盘货箱条码信息写入电子标签中，实现条码与标签的关联，并将信息传给中央管理系统。

(2)仓储环节进行托盘货箱变更或零散货箱拼装---采用RFID移动式读写设备把调整后的货箱数据与标签的重新关联，将新的信息写入标签，同步更新中央数据库。

(3)托盘出库---通过固定式RFID读写设备及地埋式天线采集电子标签信息，并上传至中央管理系统，系统验证后将数据解压形成货箱条码信息，实现与一打两扫商业到货扫描系统的对接。

(4)配送中心接收---托盘在阅读区停留2－3秒就可以完成整个托盘上的货箱的扫码，无需拆垛单件扫码再装垛。

四、系统优点

本方案采用无源电子标签，寿命长，免维护，设计独特，而且可以很好地嵌入塑质托盘，不易在托盘运输过程中受到碰撞、磨损。此外，电子标签可重复写入数据，有利于解决托盘货物调整，拼装等仓储物流问题，标签能循环使用，大幅度节约了用户成本。

系统实现远距离识别，读写快速可靠，能适应传送带运转等动态读取，并且适应卷烟生产厂等工业生产环境（件烟的堆垛），具有较好的抗金属干扰能力，可以克服卷烟金属箔包装对RFID识别的影响，符合现代化物流的需要。

在标签信息处理中采用了先进的数据压缩技术，使电子标签携带托盘载物信息（数据包），只需扫描托盘电子标签一次即可了解物品信息，免除拆托盘和重装托盘所需的人力物力，节省时间，降低出错率和货物损坏机率，实现快捷准确的库存盘点，提高企业物流的整体透明度。

五、系统实施效益

本方案采用远距离RFID技术，极大地提高了出入库扫码的速度与准确性，提高了物流的运行效率，解决了拆托盘、装托盘带来的劳动力成本上升、现场控制困难等难题。系统在物流环节中的成功应用，为整个烟草行业物流领域应用RFID技术总结了经验，奠定了基础，树立了典范。

RFID Projects, RFID Module, RFID Reader, Tags อุปกรณ์ สินค้า ราคา

RFID Parking Management

2011-08-24T22:27:00.000-07:00

RFID parking management

Application background

With the national economic inter-building and continuous development of the continuous improvement of overall strength, cars have been getting into millions of households. The face of automotive era, the entire community to the requirements of the smart car parks will also be getting higher and higher. HUC technologies provides the latest generation of UHF RFID Products Radio Frequency Identification, which composed of intelligent car park management system will replace the traditional management approach of artificial charges to meet the accelerating pace of life of today's car park management request。Radio frequency automatic identification system, electronic toll collection is a kind of a "radio frequency automatic identification number, model, remote electronic tag card charges, computer management, image matching and the detector calibration," the most novel way of automatic toll collection , road traffic management are moving toward digitization, automation infrastructure.

Practical significance

A. Establish a new image of the property management

The modernization of the use of high-tech products, we will make the property management enterprise image and reputation have been greatly improved. The form of a smart car park management system, both from product design, or automatically bring about the advanced and scientific management, will give the property management to establish a good image, so that enterprises have become the scientific management model

B. Strict management fees

Artificial cash for the current charges on the one hand, labor-intensive, low efficiency, one of the main drawbacks of the other financial existence is a huge loophole cause the loss of cash. The use of radio frequency intelligent car park management system, all fees are recognized and computer statistics, to eliminate the errors and fraud to protect the car and the interests of investors

C. Strengthen the safety management

One car one card, and data archiving to ensure the safety of parking the car park. Artificial issuers, collection card, it is inevitable that when the omission because there is no record available at any time,丢车or misrepresentation丢车phenomenon has happened to the car park brings about a lot of troubles and financial losses. The form of a smart car park management system, monthly card and stored-value card consumer computer record in the corresponding data, after the card is lost in time to re-submit. The hourly rate for lost cards can also be retrieved at any time, timely treatment. In contrast with images of equipment, the types of license plate numbers of parking cards are archived on one card, the vehicle registration prompted wrong computer at any time and warning

D. Good security features

Since radio frequency identification cards are highly confidential, and its encryption generally takes decades of computer time solution can not, so not easy to counterfeit

E. Durable and reliable, fully automated operation

The system uses passive radio frequency identification cards, maintenance-free, long life, Fully Sealed, non-contact, dust-proof water-proof, no need to artificially open the gate, the system auto-reader, inspection cards, open the gate, not only save manpower also save time.

Technical Overview

Microwave radio frequency identification (UHF RFID) technology is the most advanced fourth-generation automatic identification technology, are just beginning to rise in recent years and the rapid popularization and application of a new technology. It has to identify distance and the high rate of recognition accuracy, identification speed, anti-interference ability, long service life, to penetrate non-metallic materials characteristics such as the use of a wide range of. Intelligent car park management system, through the long-range passive RFID technology to effectively prevent the human factor to the car park management of the damage and interference, and achieve buildings, car parks community property intelligent scientific management, can control the cost of wastage, improve operational efficiency , ensure the safety of vehicles.

Car park management vehicle users fall into two broad categories

A. Fixed users: the car park are frequent, almost every day out of the car park to be managed on many occasions

B. Temporary user: access only occasionally refers to the management of car parks were once individual

For fixed users, the existing car park management system uses a monthly card hair Ways to reduce his (her) out of the car park at the time of their registration procedures. However, the current monthly pass cards are mostly used close-up card, each time when entering and leaving the car park the driver must also shake the windows open, put a monthly pass card reader equipment before sloshing out of a few, can lift up to allow traffic into and out of the railings

If you are using long-range monthly cards, as long as the monthly card affixed to car windshields, the arrival of each vehicle parking lot gate, the card reader device can determine the distance and control挡杆automatically lifted, so the vehicle can be fixed users do not have to Parking. This greatly enhance the efficiency of the vehicles, a reduction of pollution; simultaneously removes the weather is inclement weather, such as all the inconveniences caused

4. Equipment Composition

Remote reader device comprises

A. Electronic tags (which is usually described as "card") has been recorded in the electronic tag affixed to the vehicle in the parking lot Management Office of the legitimate registered number as well as the system must consider the characteristics of certain vehicle information. At present, the company to market the United States are imported from the ultra-high frequency electronic tags, the tags for the passive maintenance-free card, reading distance up to more than 7 meters, it used plastic film packaging, comes with paste layer can be directly attached to the car windshield on the use of

B. Reader: microwave antennas used to automatically read the electronic tags on the inside, as the data and to determine the legality of the conduct of electronic tags. The company developed its own secondary reader are specifically for car park management system and launched long-range reader, it has Wiegand26 or RS485, RS232 data output interface can be used with the market in line with the above-mentioned standard interface controller is directly connected without the need to change the existing car park management system of any software and hardware. The general reader through the RS485 port with the car park management system controller connected to each reader to read a number automatically put card number is sent to the controller, the controller to determine the effective number, open the Road vehicle access gate release

C. Reader through the field of microwave antennas transmit signals and receive electronic tag return signal.

RFID Projects, RFID Module, RFID Reader, Tags อุปกรณ์ สินค้า ราคา

停车场行业应用

一、应用背景

随着国家经济间建设的不断发展和综合实力的不断提高，小汽车已经逐步走进千家万户。面对汽车时代的来临，整个社会对于智能停车场的要求也将越来越高。创远科技公司提供了最新一代的UHF RFID射频识别产品，由它组成的智能停车场管理系统将取代传统的人工收费的管理办法，满足了生活节奏不断加快对当今停车场管理提出的要求。射频自动识别不停车收费系统是一种采取“射频自动识别车号、车型，远距离电子标签卡收费，计算机管理，图像比对及检测器校验”的最新颖的自动收费方式，是公路交通管理走向数字化、自动化的基础设施。

二、现实意义

1、树立全新的物业管理形象

现代化的高科技产品的使用，一定会使企业的物业管理形象和知名度得到很大的提高。采用智能停车场管理系统，无论从产品的造型方面，还是自动管理所带来的先进性和科学性，都将会给物业管理树立起良好的形象，使企业成为科学管理的楷模。

2、严格的收费管理

对于目前的人工现金收费方式，一方面劳动强度大，效率低，另外一个主要的弊端就是财务上存在很大的漏洞易造成现金流失。使用射频智能停车场管理系统之后，所有车辆的收费都是经过电脑确认和统计，杜绝了失误和作弊，保障了车场投资者的权益。

3、加强了安全管理

一卡一车，资料存档，保证停车场停放车辆的安全。人工发卡、收卡，难免有疏漏的时候，因为没有随时记录可查，丢车或谎报丢车的现象时有发生，给停车场带来诸多麻烦和经济损失。采用智能停车场管理系统之后，月租卡和储值卡消费者均在电脑中记录了相应的资料，卡丢失后可及时补办。时租卡丢失也可随时检索，及时处理。在配有图象对比设备情况下，各类停车卡均有车牌号码存档，一卡专用，车牌不对电脑随时提示，并提出警告。

4、防伪性能好

因为射频识别卡的保密性极高，它的加密功能一般电脑花上十年的时间也解不了，所以不容易伪造。

5、耐用可靠，操作过程全自动化

本系统采用的无源射频识别卡，免维护，使用寿命长，全密封，免接触，防尘防水，无需人为开启闸门，系统自动读卡、验卡，打开闸门，既节约人力又节省时间。

三、技术简介

微波射频识别（UHF RFID）技术是国际上最先进的第四代自动识别技术，是近几年刚刚开始兴起并得到迅速推广应用的一门新技术。它有识别距离远、识别准确率高、识别速度快、抗干扰能力强、使用寿命长、可穿透非金属材料等特点,运用范围广。智能停车场管理系统通过远距离无源射频识别技术有效防止了人为因素给停车场管理带来的破坏和干扰，实现大厦、物业小区停车场的智能化科学管理，可控制费用流失,提高运营效率，确保车辆安全。

停车场管理的车辆用户分为两大类：（一）固定用户：是该停车场的常客，几乎每天都要进出被管理停车场多次；（二）临时用户：是指偶尔才出入被管理停车场一次的散客。　

针对固定用户，现有的停车场管理系统采用发月票卡的方法来减少他（她）们进出停车场时的登记检查手续。但目前月票卡大多采用近距离卡，每次进出停车场时驾驶人员还必须摇开玻璃窗，把月票卡伸到读卡设备前晃动几下，才能使挡杆抬起允许车辆进出。

如果使用远距离月票卡，只要把月票卡贴在汽车挡风玻璃上，每次车辆到达停车场闸口时，远距离读卡设备即可判断并控制挡杆自动抬起，因此固定用户车辆可以不必停车。这极大地提高了车辆的通行效率，减少了污染；同时免除了刮风下雨等恶劣天气造成的种种不便。

四、设备组成

远距离读卡设备的组成包括：

（1）电子标签（也就是通常所说的“卡”）电子标签上记载有所贴车辆在停车场管理处登记在册的合法编号，以及系统认为必须的某些车辆特征信息。目前，公司推向市场的是从美国引进的超高频电子标签，该标签为无源免维护卡，读取距离可达7米以上，它采用塑料薄膜封装、自带粘贴胶层，可以直接贴在汽车挡风玻璃上使用。

（2）读写器：用来自动读取微波天线视场内电子标签上的数据，并进行电子标签合法性判断。公司自行二次开发研制的读写器是专门针对停车场管理系统应用而推出的远距离读写器，它具有Wiegand26或RS485、RS232等数据输出接口，能够与市场上使用的符合上述接口标准的控制器直接相连，而不需要改变现有的停车场管理系统的任何软件和硬件。读写器一般通过RS485口与停车场管理系统中的控制器相连，读写器每读到一张卡号时，自动把卡号发送到控制器，控制器判断为有效卡号后，打开道闸放车通行。

（3）读写器经过微波天线向外发射信号并接收电子标签返回信号。

附录：电子标签性能指标

（1）工作频率： 902～928 MHz；

（2）有效识读距离最大可达10米（注：距离因采用的天线和读写器的发射功率不同而变化）；<BR>

（3）无源卡设计，无需电池；

（4）内存容量：EEPROM内存1024bits，可进行读、写、擦除再写操作。以字（32bits）为单位存储编址和存储锁定，其中96 Bit用作系统参数在出厂时已锁定，928 Bit为用户应用开发区。用户可对指定字区永久写保护，使应用系统安全可靠；

（5）内存可反复擦写100，000次以上，有效使用寿命可达十年以上；

（6）读写速率：理论上，从单个标签上读取32bits耗时少于1.5 ms ，从单个标签上写入32bits耗时少于30 ms；

（7）防冲突：采用二进制树防冲突协议，允许工作区内有多个标签时的可靠读写；

（8）标签采用薄膜塑料封装，具有一定的防拆功能；

（9）工作温度：－20℃ ～＋70℃ ，储存温度： -40℃ ～＋85℃ ；（10）体积：45mm*33mm*0.8mm。

RFID Projects, RFID Module, RFID Reader, Tags อุปกรณ์ สินค้า ราคา

RFID library management

2011-08-24T22:08:00.000-07:00

RFID library management

People always want something in the required information, they can quickly find them. However, in all types of large libraries, government agencies and enterprises archives records management staff, we often see the information management staff in order to find a specific book or file of the anxious and busy.

A long time, the record book or file flow process, quickly find the information so that people spent the brain. Traditional practices are recorded in the data and to do this in a large number of written records, but this approach is inefficient and not easy to view, and there is a theft and loss of potential.

In an increasingly cost and efficiency of the pursuit of an era, it is constantly looking for better technologies and methods books File management. RFID technology, developed the RFID book file management system that can greatly improve management, enhance work efficiency, the liberation of books archives staff to enable them to engage in more valuable work.

CHAFON technology RFID books file management system, give every book file to install an electronic tag, electronic tag through the tiny chips and antennas, can easily track and Record Book file in the mobile process through which each of the locations. Book file to go through the various check points or when the office will be recorded, but also in the internal network from any computer above it is clear that users can easily know the location of library files and store the current location, to confirm the book files removed or deposited into the state. This tracking system is very convenient to use, and are vulnerable to both books and archives management system integrated with

System Structure

CHAFON technology RFID books file management system mainly includes five parts:

1. Data Center: data from a central server and the management terminal of the file management information on the book focus on storage and treatment.

2. House management system: from the management of terminals and terminal tag issuance and printing of the book files to complete the unification of information RFID tags create new files and books, etc.

3. Flow management system: In the book file and lending to help the administrator to write the relevant information within the tags to return books when the test file and verify RFID tags inside information

4. Inquiry System: Through the management of terminals and handsets easier to query every single book file

5. System Management: the system functions and permissions settings, account management, etc.

System function

1. Inbound file management books: New books file storage, according to the book file type, year and author information and other related files for new books to catalog and print data to generate RFID tags. And in accordance with print data, write and print RFID labels, RFID tags will print well paste it into the book file for readers to access data simultaneously print the success of data center will be transferred to the database, for system calls and other modules query

2. Circulation Management: Distribution Management is divided into loan management module, the return of the management module and theft Loss Prevention Module

3. Lending, the system will first verify the identity of people borrow to verify access to borrow after the adoption of management systems. Lending people access through the query management system file cataloging its books, the system under the Importation of cataloging its search to book the location of the file, at the same time print out a single loan. Administrators use the RFID reader to read out the loan to borrow books by people with RFID file written information, the information automatically into the system management interface. Administrator in writing within RFID tags were fixed to borrow books file information, including names of people to borrow, units, lending time period, such as loan information, it will borrow the book files to complete the loan people management

4. Book file the return, the administrator uses RFID reader to read out the book files, check the information people to borrow and to borrow time is extended, was to borrow books to confirm whether the data file with the RFID tags of the same information. This process if there is problem, the system will enter the appropriate processing module for processing, no problem according to RFID in the book file location information back to the corresponding location

5. Loss Prevention module with theft of books archives export security device, track files of books, not for lending End procedures or prohibit lending book file in the home, the security device will alarm to remind managers a timely manner to prevent

6. Data Center Management: including data management, collection and statistics, equipment and systems management

7. Data management mainly refers to the catalog file on its books, personnel information, year, and other basic information storage, revision and updating of management, as well as administrator of the library file for certification. Data Acquisition is the collection of books to borrow and return the relevant file information. Data are mean time (day, week, month, year), the book file information (department, personnel, etc.) for data statistical analysis

Equipment management refers to the handset, read and write information such as equipment authorization and configuration management and maintenance

System Features

1. Completely non-contact systems, the most economical solution: non-contact chip will be embedded into the low-cost medium, can be the greatest degree of solutions to meet the needs of the application of this advanced technology can dramatically reduce the equipment investment and maintenance costs as well as the hardware the cost of wear and tear

2. Quick scan, accessible reading: RFID tags are not required to scan a straight line at the reader, to read and write speed. At the same time, RFID is based on radio waves to transmit information, there will be no transmission barrier problem

3. Safety, flexibility: RFID tags can be divided into various independent internal application region, different applications of data storage. Each electron has a tag 32 of the world's only serial number, the serial number written in the production process, can not be changed

4. Easy to implement and easy to use: The system is very easy to install and debug, use and operation of the latter is also very convenient maintenance, search, identification book files fast, and anti-theft loss prevention, be able to provide reliable performance and a high degree of security

RFID Projects, RFID Module, RFID Reader, Tags อุปกรณ์ สินค้า ราคา

图书档案管理

人们总是希望在需要一件资料的时候，可以迅速地找到它们。但在各类大型图书馆、政府机构档案馆和企事业单位人员档案管理处，我们经常会看到资料管理人员为了寻找某本特定书籍或档案而着急忙碌。

长久以来，记录图书或档案流动过程，快速找到该资料，使人们费尽了脑筋。传统做法是在资料上和记录本中做大量的文字记录，但这种做法效率低，查看又不便捷，而且存在着被盗和丢失的隐患。

在一个越来越追求成本与效率的时代，人们不断的寻找更好的技术和方法进行图书档案管理工作。创方科技运用RFID技术，开发的图书档案管理系统，可以大大改进管理方式、提高工作效率，解放图书档案工作人员，让他们从事更有价值的工作。

创方科技RFID图书档案管理系统，给每一件图书档案安装一个电子标签，通过电子标签的微小芯片和天线，可以方便地跟踪和记录图书档案在流动过程中所经过的每一个地点。图书档案经过不同的办公室或者检查点时，都会得到记录，而且在任何一台内部网络电脑上面可以清楚看到，用户可以很方便的知道图书档案目前的位置和存放的地点，确认图书档案的取出或者存入状态。这个跟踪系统使用十分方便，而且很容易与既有的图书档案管理系统整合在一起。

系统结构

创方科技RFID图书档案管理系统主要包括五个部分：

1．数据中心：由中心数据服务器和管理终端组成，对图书档案管理信息集中进行储存和处理。

2．内务管理系统：由管理终端和标签发行和打印终端组成，可以完成图书档案信息RFID标签的统一制作和图书档案新建等工作。

3．流通管理系统：在图书档案借出时帮助管理员在标签内写入相关信息，归还时检验图书档案并验证RFID标签内信息。

4．查询系统：通过管理终端和手持机方便地查询每一件图书档案的位置。

5．系统管理：对系统功能及权限设置，帐号管理等。

系统功能：

1．图书档案管理入库：新图书档案入库时，根据图书档案的类别、年份和作者等相关信息对新建图书档案进行编目，并生成RFID标签打印数据。然后根据打印数据，写入并打印RFID标签，将打印好的RFID标签贴到图书档案上，以便读者查阅，同时打印成功的数据会被传送到数据中心的数据库里，以备系统其他模块调用和查询。

2．流通管理：流通管理分为借阅管理模块、归还管理模块和防窃防损模块。

3．借阅时，系统首先会验证借阅人身份，验证通过后进入借阅管理系统。借阅人通过查询管理系统查阅图书档案的编目号，系统根据输入的编目号查找到图书档案所在的位置，同时打印出借阅单。管理员使用RFID读写器读出借阅人所借阅图书档案RFID内写的信息，信息自动进入系统管理界面。管理员在 RFID标签内写入被借阅图书档案的固定信息，包括借阅人的姓名、单位、借出时间、借阅期限等信息后，将图书档案给借阅人完成借阅管理。

4．图书档案归还时，管理员使用RFID读写器读出图书档案，检查借阅人信息、借阅时间是否超期，确认被借阅图书档案数据是否与RFID标签中的信息相同。这个过程中如有问题，系统会进入相应的处理模块进行处理，没问题则根据RFID中的图书档案位置信息送回相应的位置。

5．防窃防损模块配合图书档案馆的出口安检装置，对图书档案进行跟踪，未办理完借出手续或禁止借出的图书档案在出门时，安检装置会报警，提醒管理人员及时阻止。

6．数据中心管理：包括数据的管理、采集和统计，设备和系统的管理

7．数据的管理主要是指对图书档案的编目号、人员信息、年份等基本信息的存储、修改和更新管理，以及对图书档案的管理员进行认证。数据采集是指采集借阅和归还图书档案的相关信息。数据统计是指按时间（日、周、月、年）、图书档案信息（部门、人员等）进行数据统计分析。

设备的管理是指对手持机、读写器等设备的信息授权与配置管理与维护。

系统的管理是指系统操作员授权及维护，操作人员授权控制。

图书档案查询：按不同方式查阅图书档案的编目号；按不同的规则查询图书档案所在位置，查阅图书档案的简介等。

系统特点

1、完全非接触系统，最经济的解决方案：将非接触芯片嵌入到低成本的介质中，可以最大程度的满足解决方案的需要，应用这一先进技术可以大幅度减少设备的投资和维护费用以及硬件磨损的成本。

2、快速扫描，无障碍阅读：RFID标签扫描时无须直线对准读取器，读写速度快。同时，RFID是以无线电波来传递信息，不会有传输屏障的问题。

3、安全性高，灵活性强：RFID标签内部可以分为各个独立的应用区域，存放不同的应用数据。每一张电子标签都有一个32位的全球唯一的序列号，该序号在生产过程中写入，无法更改。

4、实施简单，使用方便：系统安装和调试非常简单，后期的使用和运营维护也十分便捷，查找、识别图书档案速度很快，而且防盗防损，能够提供可靠的性能和高度的安全性。

USB KEY RFID Reader

2011-08-24T02:24:00.000-07:00

USB KEY RFID Reader

Model:CF-RH360

CF-RH360 proximity reader is a 13.56MHz ISO 14443 Type A/B compliant reading/writing device; it’s of compact size and looks just like an U disk. With internal antenna, its typical operating distance is 20-50mm. With a standard USB2.0 communication interface, it is ready to “plug and play” wherever. Its compact size, low power consumption and versatility allow a flexible and efficient application or integration in different configurations and systems, especially for movable applications.

Specification:

Model	CF-RH360
Operating Frequency	13.56MHz±7KHz
Operating standards	ISO 14443 Type A/B, Mifare1
Operating power	9V DC
Read Range	20 ～ 50mm
Communication	USB 2.0
Indicator	Buzzer
Power supply	USB powered
SDK	DLL and Demo. Software in VB or Delphi
Operating Temperature	-20℃ ～ +65℃
Storage Temperature	-40℃ ～ +85℃
Humidity	45 ％ RH ～ 85%RH( non-condensing)
Dimension	7665 10.5mm(L x W x H)
Weight	30g

Application:

                      Membership management
                      Brand protection and security
                      Medicine and pharmacy management
                      Violation of transportation rules handling

Smart tickets

Access control
Post service management

Smart Patrol

RFID Smart Gate-Channel Identify Equipment

2011-08-24T02:10:00.000-07:00

RFID Smart Gate-Channel Identify Equipment

Introduction:

MR8000A is a smart gate-channel device that based on RFID technology, which has built-in

antenna and reader module, it can be used in RFID logistical or warehouse management system,

bank treasury money box in and out management, etc.

It can be widely used in many RFID systems, the typical application field is as following:

Logistic and warehouse management: goods flowing

☆ and warehouse management, as well some package of post office and luggage’ s flowing management;

☆Supply chain application field: for tracking the goods supply’s full process;

☆Product security checking: adopt the tag’s memory write-protected function to check true or false of the product;

☆Others application field: always widely used in club management, library management, student enroll management, consumption management, registration management, dining hall management, swimming pool management, etc.

Features of Reader module:

●Adopt special anti-collision algorithm, realize quite more multi-tag identify ability

●Four built-in antennas for sending and receiving increase the identify area in real application

●Comply with ISO 18000-6B and ISO 18000-6C (EPC-GEN2) protocol standard

●Identify ability : more than 5 meters (depending on the tags type and size)

●Reader provide multi-tag indentify, single tag read and write, even lock or kill tag’ function

Specification Model type MR 8000A

Support protocol ISO18000-6C（EPC GEN2）

Working frequency Standard configuration is ISM 902～928MHz or ISM 865～868MHz for optional, customize other frequency

Working mode （FHSS）

RF power 0~30dBm (software adjusted, adjust power for changing the identify range)

Communication interface : Standard configuration RS232， RJ45（TCP/IP）

Antenna Built-in antenna

Identify distance The maximum indentify range is 5 meters

Body material Stainless Steel box

Installation accessories : Four ￠12mm installation hole, used to fix the screw

Power supply AC100V~240V(AC),

Size 30mm×20mm×160mm(L*W*H)

Weight 15 Kg (single Gate)

Working temperature－20℃ ~＋80℃

USB-Keyboard emulator RFID Module

2011-08-24T01:44:00.000-07:00

USB-Keyboard emulator RFID Module

With the function as USB-Keyboard emulator, HF RFID Module SL040 is a mini Mifare read-only module which is applicable for 13.56MHz. It can read the unique serial number for all Mifare cards, including Mifare 1k, Mifare 4k, Mifare Mini, Ultralight, DesFire and Mifare ProX etc. In addition, SL040 can support to read data from Mifare 1k, Mifare 4k and Ultralight. Its output format can be set by SL040Config.exe tool.

Model	Mifare Module SL040
Frequency	13.56MHz
Protocol	ISO14443A
Tag supported	Ultralight, Mifare Mini, Mifare 1k, Mifare 4k, FM11RF08, Mifare Plus, DesFire, Mifare_ProX only UID readable
Interface	USB
Supply voltage	4.5 - 5.5 VDC
Dimension	65 × 46 mm

MAIN FEATURES

• USB Keyboard Emulator, Plug and Play

• Frequency: 13.56MHz

• UID read supported: Mifare Mini, Mifare 1k, Mifare 4k, Mifare Plus, Ultralight, DesFire & Mifare_ProX

• Data read supported: Mifare Mini, Mifare 1k, Mifare 4k and Ultralight

• Integrated antenna, LED and Buzzer

• Working current less than 80mA @5.0V

• Operating distance: Up to 60mm, depending on tag

• Storage temperature: -20 ºC ~ +85 ºC

• Operating temperature: -10 ºC ~ +70 ºC

• Dimension: 65mm × 46mm × 7 mm

RFID User Manual & Tools

SL040 User Manual

Config Tools

CompactFlash RFID Reader Card

2011-08-19T02:49:00.000-07:00

Socket Communications CompactFlash RFID Reader Card

Product Description

Add plug-in RFID capabilities to Pocket PC applications

Now add high frequency RFID capabilities to your mobile data collection application with Socket’s CompactFlash RFID Reader Card. This product reads and writes to all ISO 15693 and many proprietary 13.56Mhz RFID tags being used or deployed for asset tracking, access control, process control, healthcare and pharmaceutical applications.
Like all Socket’s data collection products, the RFID Reader card is supported by SocketScan keyboard wedge software which sends the RFID tag ID, data from selected memory blocks or both to any Windows application as virtual keystrokes – No custom programming needed! A small RFID Demo application allows writing to the accessible tag memory blocks for demonstration purposes. The SocketScan SDK is available for developers who wish to embed control of the RFID Reader read/write functionality into their applications.

Mobility Friendly Means Low Power

As with all of our products, Socket designed the Mobility Friendly CF RFID Reader to use minimal power. Drawing only 11mA (36mW) in idle mode, the CF RFID Reader will operate for hours without having to recharge the batteries in your Pocket PC.

CF RFID Reader Card Features:

Integrated Type II CF card plugs into the Type II CompactFlash slot of Windows Powered Pocket PCs
High Frequency – 13.56MHz Reader/Writer
Read range – Approx. 3.5 inches (8.9 cm) – Varies with size of tag antenna
Reads and writes to the most popular HF ISO 15693 tags, including ICode SLI/SL2, LRI512, my-d and Tag-It HF-I
Reads and writes to ICode 1, Tag-It HF and PicoTag proprietary HF tags
Support for reading in Inventory and/or Loop Mode
LED indicates read activity
Supported by the same SocketScan and SDK that supports all Socket data collection products
Socket's SocketScan software sends tag ID and/or data from selected memory blocks to any Windows application as virtual keystrokes
SocketScan enables the creation of prefixes and suffixes, such as Tab or Carriage Return, to further eliminate key strokes in the data collection process
SocketScan enables the assignment of a beep tone to signify a successful read
This Battery Friendly solution draws only a few milliamps of current in standby mode, extending the battery life of your Pocket PC
No extra batteries or special power adapter required. The RFID Reader Card gets power from the host Pocket PC
Works with Windows-based development tools so you can easily create custom applications

Product Description

CF RFID READER CARD HF CF HIGH FREQUENCY(13.56MHZ)

Technical Details

Integrated Type II CF card plugs into the Type II CompactFlash slot of Windows Powered Pocket PCs
Add plug-in RFID capabilities to Pocket PC applications
Reads and writes to the most popular HF ISO 15693 tags, including ICode SLI/SL2, LRI512, my-d and Tag-It HF-I
High frequency, 13.56MHz reader/writer
Reads and writes to ICode 1, Tag-It HF and PicoTag proprietary HF tags

Product Details

Product Dimensions: 5.8 x 5.2 x 1.9 inches ; 7.4 ounces
Shipping Weight: 1 pounds
Shipping: Currently, item can be shipped only within the U.S.
ASIN: B0009KVVIG
Item model number: RF5400-542

RFID for Dummies Ebook

2011-07-18T07:28:00.000-07:00

RFID for Dummies Ebook

About the Author
As you may have guessed by the dangling participles and misused gerunds, this is the first book by Patrick J. Sweeney II (despite Amazon’s link to books on gynecology by an author of the same name). When not negotiating with his editor to push back book deadlines, he leads ODIN technologies as President and CEO.
ODIN technologies is a global RFID software and services company focusing on RFID infrastructure. Mr. Sweeney is well recognized as a visionary in the RFID industry with several RFID patents in various stages of approval. He has appeared in such publications as CIO Magazine, The Washington Post, Fortune magazine, Internet Week, and many others. He has been interviewed by ABC news and CNN, among others, and is a frequent speaker worldwide on all topics relating to RFID. He is also an active member of several standards bodies and regulatory groups helping to shape the evolution of the RFID
industry.

Mr. Sweeney is a second-generation IT professional; his father was one of the first employees at Electronic Data Systems (EDS), where “Pops” entertained him and his brother on weekends by teaching them to read punch cards and other useful skills. Mr. Sweeney took that genetic proclivity toward data centers and started a successful, secure managed hosting company in the late 1990s, which he later sold. His brother took that same early training and started XS Speed Choppers, making custom motorcycles — go figure.

Mr. Sweeney finished second in the 1996 Olympic trials in the single scull, is an avid outdoorsman, enjoys helping other entrepreneurs, and is passionate about various Irish causes. He is a board member of Trinity College business school in Dublin, Ireland, and an Alumni Board member at the Darden School of Business at the University of Virginia. He graduated from Darden and received a Bachelor of Science degree from the University of New Hampshire.
He is blessed with a great family—wife Christen, daughter Shannon, son P.J., and three dogs. They live in Middleburg, Virginia, in a house full of useless RFID gadgets.
TEAM

UHF Handheld RFID Reader

2011-07-16T19:21:00.001-07:00

MR6081A UHF handheld RFID reader data collection device design base on industry standard, this device compaible multi protocols, multi data communication interface and industry rate design (IP65) etc, it can widely use in varies RFID system as below:

1. Logistics and warehouse management: Goods flow, warehouse management, and the flowing management of mail, parcel, luggage
2. Supply chain application area: item supply process application etc
3. Product counterfeit-proof inspection: using memory's write-protect function inside tags, and identifying with true-false of products.
4. Other fields: used widely in club management, libary, school, consumption management, time management, dinner management, pool management.

Characteristic:1. Embed with simply operation system, RFID data collect, storage function.
2. Full-featured with Bluetooth, WIFI, GPS, 2D barcode, 1D barcode.
3. Exceptional ergonomics ensure comfortable usage.
4. ID function supply multi protocol configuration, easy to operate.
Technical Parameters

Model	MR6081A
Protocol	ISO18000-6B，ISO18000-6C（EPC GEN2）
Frequency Range	StandardISM 902～928MHz or ISM 865～868MHz,other frequency available
Operation Mode	FHSS
RF Power	0~30dBm,software adjustable
Identify Distance	Read 2m (card type), write 1.5m (card type)
Operating System	Microsoft WinCE 5.0
CPU	Sc2440 Samsung 400MHz
Memory Capacity	64M Flash ROM, 64MROM
Data Interface	standard: Bluetooth, WIFI custom-made:1D barcode, 2D barcode, GPS, GPRS
Power Supply	3.7V (lithium battery) supply power adapter
Working Time	Can sustaining working over 9 hours
Protection Grade	IP65
Net Weight	0.5KG
Dimension	210mm×90mm×53mm
Operation Temp	－20℃~＋80℃

MIFARE Ultralight Tags

2011-07-16T19:11:00.000-07:00

MIFARE Ultralight Tags

The MIFARE MF0ICU1 has been developed by NXP Semiconductors for use with Proximity Coupling Devices (PCD) in accordance with ISO/IEC 14443 A. It is intended for use with single trip tickets in public transportation networks, loyalty cards or day passes for events as a replacement for conventional ticketing solutions such as paper tickets, magnetic stripe tickets or coins.

As the usage of contactless proximity smart cards becomes more and more common, transport and event operators are switching to completely contactless solutions. The introduction of the MIFARE Ultralight for limited use tickets will lead to a reduction of system installation and maintenance costs. Terminals will be less vulnerable to damage and mechanical failures caused by ticket jams. MF0ICU1 can easily be integrated into existing schemes and even standard paper ticket vending equipment can be upgraded. This solution for low cost tickets can help operators to reduce the circulation of cash within the system.

The mechanical and electronical specifications of MIFARE Ultralight are tailored to meet the requirements of paper ticket manufacturers.

Key applications

• Limited use tickets for public transport

• Limited use tickets for event ticketing

Contactless energy and data transfer

MF0ICU1 is connected to a coil with a few turns. The MF0ICU1 fits the TFC.0 (Edmondson) and TFC.1 (ISO) ticket formats as defined in BS EN753-2.

TFC.1 format tickets are supported by the MF0ICU10 chip which features a 17 pF on-chip resonance capacitor.

The smaller TFC.0 format tickets are supported by the MF0ICU11 chip which features a 50 pF on-chip resonance capacitor.

Anticollision

An intelligent anticollision function enables simultaneous multicard operation. The anticollision algorithm individually selects each card and ensures correct execution of a transaction with the selected card without data corruption from other cards in the field.

Cascaded Unique IDentification (UID)

The anticollision function is based on an IC individual serial number called Unique Identification (UID) for each IC. The UID of the MF0ICU1 comprises 7 bytes and supports ISO/IEC 14443-3 cascade level 2.

Security

• 7-byte UID in accordance with ISO/IEC 14443-3 for each device

• 32-bit user definable One-Time Programmable (OTP) area

• Field programmable read-only locking function per page

Delivery options

MF0ICU1 can be delivered in packaged or wafer form. Refer to delivery type description for more information.

Features and benefits

MIFARE RF interface ISO/IEC 14443 A

􀂄 Contactless transmission of data and supply energy (no battery needed)

􀂄 Operating distance up to 100 mm depending on antenna geometry

􀂄 Operating frequency of 13.56 MHz

􀂄 Data transfer of 106 kBs

􀂄 Data integrity of 16-bit CRC, parity, bit coding, bit counting

􀂄 Anticollision

􀂄 7-byte serial number in accordance with ISO/IEC 14443-3 cascade level 2

􀂄 Typical ticketing transaction time of < 35 ms

􀂄 Fast counter transaction time of < 10 ms

EEPROM

􀂄 512-bit, organized in 16 pages with 4 bytes per page

􀂄 Field programmable read-only locking function per page

􀂄 32-bit user definable One-Time Programmable (OTP) area

􀂄 384-bit user Read/Write area (12 pages)

􀂄 Data retention time of 5 years

􀂄 Write endurance 10000 cycles

Functional description

Block description

The MF0ICU1 chip consists of a 512-bit EEPROM, RF interface and Digital Control Unit (DCU). Energy and data are transferred via an antenna consisting of a coil with a small number of turns which is directly connected to the MF0ICU1. No further external components are necessary. Refer to the document Ref. 6 “MIFARE (Card) Coil Design Guide” for details on antenna design.

• RF interface:

– Modulator/demodulator

– Rectifier

– Clock regenerator

– Power-On Reset (POR)

– Voltage regulator

• Anticollision: Multiple cards may be selected and managed in sequence

• Command interpreter: Processes commands supported by the MF0ICU1 to access the memory

• EEPROM interface

• EEPROM: 512 bits, organized in 16 pages of 4 bytes per page.

– 80 bits reserved for manufacturer data

– 16 bits used for the read-only locking mechanism

– 32 bits available as OTP area

– 384 bits user programmable Read/Write memory

Communication overview

Commands are initiated by the PCD and controlled by the MF0ICU1’s command interpreter. This processes the internal states and generates the appropriate response.

Idle state

After a Power-On Reset (POR), the MF0ICU1 switches directly to the idle state. It only exits this state when a REQA or a WUPA command is received from the PCD. Any other data received while in the idle state is interpreted as an error and the MF0ICU1 remains Idle.

After a correctly executed HALT command, the halt state changes to the wait state which can be exited with a WUPA command.

Ready 1 state

In this state, the MF0ICU1 supports the PCD when resolving the first part of its UID (3 bytes) with the ANTICOLLISION or SELECT command from cascade level 1. This state is exited correctly after execution of either of the following commands:

• SELECT command from cascade level 1: the PCD switches the MF0ICU1 into Ready 2 state where the second part of the UID is resolved.

• READ command (from address 0): all anticollision mechanisms are bypassed and the MF0ICU1 switches directly to the active state.

Remark: If more than one MF0ICU1 is in the PCD field, a READ command from address 0 causes a collision due to the different serial numbers and all MF0ICU1 devices are selected. Any other data received in the Ready 1 state is interpreted as an error and depending on its previous state the MF0ICU1 returns to the wait, idle or halt state.

Ready 2 state

In this state, the MF0ICU1 supports the PCD when resolving the second part of its UID

(4 bytes) with the cascade level 2 ANTICOLLISION command. This state is usually exited

using the cascade level 2 SELECT command.

Alternatively, state Ready 2 may be skipped using a READ command (from address 0) as described in state Ready 1.

Remark: If more than one MF0ICU1 is in the PCD field, a READ command from address 0 causes a collision due to the different serial numbers and all MF0ICU1 devices are selected. The response of the MF0ICU1 to the cascade level 2 SELECT command is the Select Acknowledge (SAK) byte. In accordance with ISO/IEC 14443 this byte indicates if the anticollision cascade procedure has finished. It also defines the type of device selected for the MIFARE architecture platform. The MF0ICU1 is now uniquely selected and only this device will communicate with the PCD even when other contactless devices are present in the PCD field. Any other data received when the device is in this state is interpreted as an error and depending on its previous state the MF0ICU1 returns to the wait, idle or halt state.

Active state

In the active state either a 16-byte READ or 4-byte WRITE command can be performed.

The HALT command exits either the READ or WRITE commands in their active state. Any other data received when the device is in this state is interpreted as an error and depending on its previous state the MF0ICU1 returns to the wait, idle or halt state.

Halt state

The halt and idle states constitute the second wait state implemented in the MF0ICU1. An already processed MF0ICU1 can be set into the halt state using the HALT command. In the anticollision phase, this state helps the PCD to distinguish between processed cards and cards yet to be selected. The MF0ICU1 can only exit this state on execution of the WUPA command. Any other data received when the device is in this state is interpreted as an error and the MF0ICU1 state is unchanged. Refer to the document MIFARE collection of currently available application notes for correct implementation of an anticollision procedure based on the idle and halt states and the REQA and WUPA commands.

Data integrity

Reliable data transmission is ensured over the contactless communication link between PCD and MF0ICU1 as follows:

• 16-bit CRC for each block

• Parity bits for each byte

• Bit count checking

• Bit coding to distinguish between logic 1, logic 0 and no information

• Channel monitoring (protocol sequence and bit stream analysis)

RF interface

The RF interface is base on the ISO/IEC 14443 A standard for contactless smart cards.

The RF field from the PCD is always present as it is used for the card power supply.

However, it is sequentially interrupted during data transmission to allow the data to be sent. There is only one start bit at the beginning of each frame for data communication irrespective of direction. Each byte is transmitted with an odd parity bit at the end of the byte. The LSB of the byte with the lowest selected block address is transmitted first. The maximum frame length is 163-bit:

(16 data bytes + 2 CRC bytes = 16 * 9 + 2 * 9 + 1 start bit = 163).

Memory organization

The 512-bit EEPROM memory is organized in 16 pages with 4 bytes per page. In the erased state the EEPROM cells are read as logic 0, in the written state as logic 1.

UID/serial number

The unique 7-byte serial number (UID) and its two check bytes are programmed into the first 9 bytes of memory covering page addresses 00h, 01h and the first byte of page 02h.

The second byte of page address 02h is reserved for internal data. These bytes are programmed by the IC manufacturer and because of the security requirements are write protected.

In accordance with ISO/IEC 14443-3 Check Byte0 (BCC0) is defined as CT ⊕ SN0 ⊕ SN1 ⊕ SN2 and Check Byte 1 (BCC1) is defined as SN3 ⊕ SN4 ⊕ SN5 ⊕ SN6. SN0 holds the Manufacturer ID for NXP Semiconductors (04h) in accordance with ISO/IEC 14443-3 and ISO/IEC 7816-6 AMD.1

Table 4. Memory organization

Page address Byte number

Decimal Hex 0 1 2 3

0 00h serial number

1 01h serial number

2 02h serial number internal lock bytes lock bytes

3 03h OTP OTP OTP OTP

4 to 15 04h to 0Fh user memory

Lock bytes

The bits of byte 02h and 03h of page 02h represent the field programmable read-only locking mechanism. Each page from 03h (OTP) to 0Eh can be individually locked by setting the corresponding locking bit Lx to logic 1 to prevent further write access. After locking, the page becomes read-only memory.

The three least significant bits of lock byte 0 are the block-locking bits. Bit 2 deals with pages 0Eh to 10h, bit 01h deals with pages 09h to 04h and bit 00h deals with page 03h (OTP). Once the block-locking bits are set, the locking configuration for the corresponding memory area is frozen.

OTP bytes

Page 03h is the OTP page and it is preset so that all bits are set to logic 0 after production.

These bytes can be bitwise modified using the WRITE command.

The WRITE command bytes and the current contents of the OTP bytes are bitwise OR’ed.

The result is the new OTP byte contents. This process is irreversible and if a bit is set to logic 1, it cannot be changed back to logic 0.

Data pages

Pages 04h to 15h are the user read/write area.

After production the data pages are initialized to the following values:

• Page 04h is initialized to FFh

• Pages 05h to 15h are initialized to 00h

Acronym Description

ARG Argument

ATQA Answer To Request (type A)

BCC Block Check Character

CMD Command

CRC Cyclic Redundancy Check

CT Cascade Tag

EEPROM Electrically Erasable Programmable Read-Only Memory

IV Initial Value

LSB Least Significant Bit

MSB Most Significant Bit

NAK Negative Acknowledge

OTP One-Time Programmable

Passive ACK Passive (implicit) ACKnowledge without PICC answer

PCD Proximity Coupling Device

PGDW Potential Good Dies per Wafer

PICC Proximity Integrated Circuit Card

POR Power-On Reset

REQA Request Answer (type A)

RF Radio Frequency

SAK Select ACKnowledge (type A)

UID Unique IDentifier/IDentification

WUPA Wake-UP command (type A)

References

[1] ISO/IEC 14443 A — International Organization for Standardization/International Electrotechnical Commission: Identification cards - Contactless integrated circuit(s) cards - Proximity cards, part 1-4, Type A

[2] MIFARE Interface Platform Type Identification Procedure — Application note, BL-ID Document number 0184, Version number **

[3] MIFARE ISO/IEC 14443 PICC Selection — Application note, BL-ID Document number 1308, Version number **

[4] MIFARE Ultralight Features and Hints — Application note, BL-ID Document number 0731, Version number **

[5] MIFARE Ultralight as Type 2 Tag — Application note, BL-ID Document number 1303, Version number **

[6] MIFARE (Card) Coil Design Guide — Application note, BL-ID Document number 0117, Version number **

For more information, please visit: http://www.nxp.com

Mifare 1K RFID Tags

2011-07-01T00:11:00.000-07:00

Mifare 1K Card.

Mifare features:
•    1K byte EEPROM
•    Embedded antenna
•    Mifare 13.56 MHz ISO 14443A
•    The range of operation is typically from about 8 cm.

RFID Reader - VB.net Source code

2011-06-22T21:01:00.000-07:00

RFID Reader - VB.net Source code

Option Strict Off
Option Explicit On
Imports VB = Microsoft.VisualBasic
Friend Class frm_main
   Inherits System.Windows.Forms.Form

   Private Sub Command1_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles Command1.Click
       Dim port, i, baud As Integer
       Dim j As Short
       Dim buf1(200) As Byte
       Dim b1 As Byte
       Dim s1 As String
       port = cb_ckh.SelectedIndex + 1
       If (port = 0) Then
           lb_info.Text = "Please select COM Port!"
       End If
       baud = CInt(cb_btl.Text)
       If (baud = 0) Then
           lb_info.Text = "Please select Baud rate!"
       End If
       'Open Port
       i = rf_init_com(port, baud)
       If (i <> 0) Then
           lb_info.Text = "Open Port Fail!"
           Exit Sub
       End If
       'Request
       i = rf_request(0, &H52s, j)
       If (i <> 0) Then
           lb_info.Text = "Request Fail!"
           Exit Sub
       End If
       'Anticollision
       i = rf_anticoll(0, 4, buf1(0), b1)
       If (i <> 0) Then
           lb_info.Text = "Anticollision Fail!"
           Exit Sub
       End If
       s1 = ""
       For i = 0 To b1 - 1
           s1 = s1 & VB.Right("00" & Hex(buf1(i)), 2)
       Next i
       tx_kh.Text = s1
       'Select card
       i = rf_select(0, buf1(0), 4, b1)
       If (i <> 0) Then
           lb_info.Text = "Select card fail!"
           Exit Sub
       End If
       lb_info.Text = "Select card succeed!"
   End Sub

   Private Sub Command2_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles Command2.Click
       Dim i, m As Integer
       Dim buf1(200) As Byte
       Dim buf2(200) As Byte
       Dim s1 As String
       Dim b2, b1, b3 As Byte
       s1 = Trim(tx_key.Text)
       If (Len(s1) <> 12) Then
           lb_info.Text = "Wrong Key Length!"
           tx_key.Focus()
           Exit Sub
       End If
       For i = 0 To 5
           buf1(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
       Next i
       m = cb_kh.SelectedIndex
       If (m = -1) Then
           lb_info.Text = "Select Block Please!"
           Exit Sub
       End If
       If (op_a.Checked) Then
           b1 = &H60s
       End If
       If (op_b.Checked) Then
           b1 = &H61s
       End If
       b3 = CByte(m)
       'Authentication
       i = rf_M1_authentication2(0, b1, b3, buf1(0))
       If (i <> 0) Then
           lb_info.Text = "Authentication Fail"
           Exit Sub
       End If
       'Read card
       i = rf_M1_read(0, b3, buf2(0), b2)
       If (i <> 0) Then
           lb_info.Text = "Read Card Fail!"
           Exit Sub
       End If
       s1 = ""
       For i = 0 To b2 - 1
           s1 = s1 & VB.Right("00" & Hex(buf2(i)), 2)
       Next i
       tx_sj.Text = s1
       lb_info.Text = "Read Succeed!"
   End Sub

   Private Sub Command3_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles Command3.Click
       Dim i, m As Integer
       Dim buf1(200) As Byte
       Dim buf2(200) As Byte
       Dim s1 As String
       Dim b2, b1, b3 As Byte
       s1 = Trim(tx_key.Text)
       If (Len(s1) <> 12) Then
           lb_info.Text = "Wrong Key Length!"
           tx_key.Focus()
           Exit Sub
       End If
       For i = 0 To 5
           buf1(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
       Next i
       m = cb_kh.SelectedIndex
       If (m = -1) Then
           lb_info.Text = "Select Block Please!"
           Exit Sub
       End If
       If (op_a.Checked) Then
           b1 = &H60s
       End If
       If (op_b.Checked) Then
           b1 = &H61s
       End If

       s1 = Trim(tx_sj.Text)
       If (Len(s1) <> 32) Then
           lb_info.Text = "Wrong Data length "
           tx_sj.Focus()
           Exit Sub
       End If
       For i = 0 To 15
           buf2(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
       Next i
       'Authentication
       b3 = CByte(m)
       i = rf_M1_authentication2(0, b1, b3, buf1(0))
       If (i <> 0) Then
           lb_info.Text = "Authentication Fail!"
           Exit Sub
       End If
       'Write card
       i = rf_M1_write(0, b3, buf2(0))
       If (i <> 0) Then
           lb_info.Text = "Write Card Fail"
           Exit Sub
       End If

       lb_info.Text = "Write Succeed!"
   End Sub

   Private Sub Command4_Click(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles Command4.Click
       Dim i As Integer
       i = rf_halt(0)
       If (i <> 0) Then
           lb_info.Text = "Halt Fail!"
           Exit Sub
       End If
       lb_info.Text = "Halt Succeed"
   End Sub

   Private Sub frm_main_Load(ByVal eventSender As System.Object, ByVal eventArgs As System.EventArgs) Handles MyBase.Load
       Dim i As Integer
       For i = 0 To 63
           cb_kh.Items.Insert(i, CStr(i))
       Next i
       cb_ckh.SelectedIndex = 0 : cb_btl.SelectedIndex = 1 : cb_kh.SelectedIndex = 4
   End Sub
End Class

Download Source code

RFID on Ebay Store

RFID Reader - C# Source code

2011-06-21T21:49:00.000-07:00

RFID Reader - C# Source code

====================================================================
MICROSOFT FOUNDATION CLASS LIBRARY : MifareOne
====================================================================

AppWizard has created this MifareOne application for you. This application
not only demonstrates the basics of using the Microsoft Foundation classes
but is also a starting point for writing your application.

This file contains a summary of what you will find in each of the files that
make up your MifareOne application.

MifareOne.dsp

    This file (the project file) contains information at the project level and
    is used to build a single project or subproject. Other users can share the
    project (.dsp) file, but they should export the makefiles locally.

MifareOne.h

    This is the main header file for the application. It includes other
    project specific headers (including Resource.h) and declares the
    CMifareOneApp application class.

MifareOne.cpp

This is the main application source file that contains the application
class CMifareOneApp.

MifareOne.rc

    This is a listing of all of the Microsoft Windows resources that the
    program uses. It includes the icons, bitmaps, and cursors that are stored
    in the RES subdirectory. This file can be directly edited in Microsoft
    Visual C++.

MifareOne.clw

    This file contains information used by ClassWizard to edit existing
    classes or add new classes. ClassWizard also uses this file to store
    information needed to create and edit message maps and dialog data
    maps and to create prototype member functions.

res\MifareOne.ico

This is an icon file, which is used as the application's icon. This
icon is included by the main resource file MifareOneถมะดภืำ.rc.

res\MifareOne.rc2

    This file contains resources that are not edited by Microsoft
    Visual C++. You should place all resources not editable by
    the resource editor in this file.

/////////////////////////////////////////////////////////////////////////////

AppWizard creates one dialog class:

MainDlg.h, MainDlg.cpp - the dialog
    These files contain your CMainDlg class. This class defines
    the behavior of your application's main dialog. The dialog's
    template is in MifareOne.rc, which can be edited in Microsoft
    Visual C++.

/////////////////////////////////////////////////////////////////////////////
Other standard files:

StdAfx.h, StdAfx.cpp
    These files are used to build a precompiled header (PCH) file
    named MifareOne.pch and a precompiled types file named StdAfx.obj.

Resource.h
    This is the standard header file, which defines new resource IDs.
    Microsoft Visual C++ reads and updates this file.

/////////////////////////////////////////////////////////////////////////////
Other notes:

AppWizard uses "TODO:" to indicate parts of the source code you
should add to or customize.

If your application uses MFC in a shared DLL, and your application is
in a language other than the operating system's current language, you
will need to copy the corresponding localized resources MFC42XXX.DLL
from the Microsoft Visual C++ CD-ROM onto the system or system32 directory,
and rename it to be MFCLOC.DLL. ("XXX" stands for the language abbreviation.
For example, MFC42DEU.DLL contains resources translated to German.) If you
don't do this, some of the UI elements of your application will remain in the
language of the operating system.

/////////////////////////////////////////////////////////////////////////////

Download Source code

RFID on Ebay Store

RFID Reader - VB Source code

2011-06-21T21:22:00.000-07:00

RFID Reader - VB Source code

Option Explicit

Private Sub Command1_Click()

Dim i&, j%, port&, baud&, buf1(200) As Byte, b1 As Byte, s1$
port = cb_ckh.ListIndex + 1
If (port = 0) Then
    lb_info.Caption = "Please select COM Port!"
End If
baud = CLng(cb_btl.Text)
If (baud = 0) Then
    lb_info.Caption = "Please select Baud rate!"
End If
'Open Port
i = rf_init_com(port, baud)
If (i <> 0) Then
    lb_info.Caption = "Open Port Fail!"
    Exit Sub
End If
'Request
i = rf_request(0, &H52, j)
If (i <> 0) Then
    lb_info.Caption = "Request Fail!"
    Exit Sub
End If
'Anticollision
i = rf_anticoll(0, 4, buf1(0), b1)
If (i <> 0) Then
    lb_info.Caption = "Anticollision Fail!"
    Exit Sub
End If
s1 = ""
For i = 0 To b1 - 1
    s1 = s1 & Right("00" & Hex(buf1(i)), 2)
Next i
tx_kh.Text = s1
'Select card
i = rf_select(0, buf1(0), 4, b1)
If (i <> 0) Then
    lb_info.Caption = "Select card fail!"
    Exit Sub
End If
lb_info.Caption = "Select card succeed!"
End Sub

Private Sub Command2_Click()

Dim i&, m&, buf1(200) As Byte, buf2(200) As Byte, s1$, b1 As Byte, b2 As Byte, b3 As Byte
s1 = Trim(tx_key.Text)
If (Len(s1) <> 12) Then
    lb_info.Caption = "Wrong Key Length!"
    tx_key.SetFocus
    Exit Sub
End If
For i = 0 To 5
    buf1(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
Next i
m = cb_kh.ListIndex
If (m = -1) Then
    lb_info.Caption = "Select Block Please!"
    Exit Sub
End If
If (op_a.Value) Then
   b1 = &H60
End If
If (op_b.Value) Then
   b1 = &H61
End If
b3 = CByte(m)
'Authentication
i = rf_M1_authentication2(0, b1, b3, buf1(0))
If (i <> 0) Then
    lb_info.Caption = "Authentication Fail£¡"
    Exit Sub
End If
'Read card
i = rf_M1_read(0, b3, buf2(0), b2)
If (i <> 0) Then
    lb_info.Caption = "Read Card Fail!"
    Exit Sub
End If
s1 = ""
For i = 0 To b2 - 1
    s1 = s1 & Right("00" & Hex(buf2(i)), 2)
Next i
tx_sj.Text = s1
lb_info.Caption = "Read Succeed!"
End Sub

Private Sub Command3_Click()

Dim i&, m&, buf1(200) As Byte, buf2(200) As Byte, s1$, b1 As Byte, b2 As Byte, b3 As Byte
s1 = Trim(tx_key.Text)
If (Len(s1) <> 12) Then
    lb_info.Caption = "Wrong Key Length!"
    tx_key.SetFocus
    Exit Sub
End If
For i = 0 To 5
    buf1(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
Next i
m = cb_kh.ListIndex
If (m = -1) Then
    lb_info.Caption = "Select Block Please!"
    Exit Sub
End If
If (op_a.Value) Then
   b1 = &H60
End If
If (op_b.Value) Then
   b1 = &H61
End If

s1 = Trim(tx_sj.Text)
If (Len(s1) <> 32) Then
    lb_info.Caption = "Wrong Data length "
    tx_sj.SetFocus
    Exit Sub
End If
For i = 0 To 15
    buf2(i) = Val("&H" & Mid(s1, i * 2 + 1, 2))
Next i
'Authentication
b3 = CByte(m)
i = rf_M1_authentication2(0, b1, b3, buf1(0))
If (i <> 0) Then
    lb_info.Caption = "Authentication Fail!"
    Exit Sub
End If
'Write card
i = rf_M1_write(0, b3, buf2(0))
If (i <> 0) Then
    lb_info.Caption = "Write Card Fail£¡"
    Exit Sub
End If

lb_info.Caption = "Write Succeed!"
End Sub

Private Sub Command4_Click()

Dim i&
i = rf_halt(0)
If (i <> 0) Then
lb_info.Caption = "Halt Fail!"
Exit Sub
End If
lb_info.Caption = "Halt Succeed"
End Sub

Private Sub Form_Load()

Dim i&
For i = 0 To 63
cb_kh.AddItem CStr(i), i
Next i
cb_ckh.ListIndex = 0: cb_btl.ListIndex = 1: cb_kh.ListIndex = 4
End Sub

Download Source code

RFID on Ebay Store

RFID Reader/Writer USB Driver Installation

2011-06-20T08:55:00.000-07:00

RFID Reader/Writer USB Driver Installation

First : To Install USB Driver ( Do not connect the RFID reader yet )

Second : Connect RFID Reader to the USB port of PC.

You can see the virtual COM No. on the “device manager ” as follows

In This sample found COM3

RFID Products Shop

RFID Module interface MCS51 Microcontroller & C Source code examples

2011-06-15T22:55:00.000-07:00

RFID Module interface MCS51 Microcontroller & C Source code examples

////////////////////////////////////////////////////////////
//Test SL025x
//MCS51 source code
////////////////////////////////////////////////////////////
#include <reg52.h>
#include <string.h>

#define true     1
#define false    0

#define OSC_FREQ        22118400L
#define TIME0_10ms      65536L - OSC_FREQ/1200L

#define BOUND4800       256 - 24
#define BOUND9600       256 - 12
#define BOUND14400      256 - 8
#define BOUND19200      256 - 6
#define BOUND28800      256 - 4
#define BOUND38400      256 - 3
#define BOUND57600      256 - 2
#define BOUND115200     256 - 1

//IO definition
sbit     CARDIN    =    P1^0;

void InitializeSystem();
void SendCom(unsigned char *g_cCommand);
void StartTime(unsigned int _MS);
void StopTime();
char ReadWriteUltralight(void);
char ReadWriteMifareStd(void);

//Command List, preamble + length + command code + data frame
unsigned char code SelectCard[3] =     {0xBA,0x02,0x01 };
unsigned char code LoginSector0[11] = {0xBA,0x0A,0x02,0x00,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
unsigned char code LoginSector1[11] = {0xBA,0x0A,0x02,0x01,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
unsigned char code ReadBlock1[4]   =   {0xBA,0x03,0x03,0x01};
unsigned char code WriteBlock1[20] =   {0xBA,0x13,0x04,0x01,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
unsigned char code ReadValue[4] =     {0xBA,0x03,0x05,0x05};
unsigned char code InitializeValue[8] ={0xBA,0x07,0x06,0x04,0x00,0x00,0x00,0x01};
unsigned char code IncrementValue[8] = {0xBA,0x07,0x08,0x04,0x00,0x00,0x00,0x20};
unsigned char code DecrementValue[8] = {0xBA,0x07,0x09,0x04,0x03,0x00,0x00,0x00};
unsigned char code CopyValue[5] =      {0xBA,0x04,0x0A,0x04,0x05};
unsigned char code ReadULPage5[4] =    {0xBA,0x03,0x10,0x05};
unsigned char code WriteULPage5[8] =   {0xBA,0x07,0x11,0x05,0x11,0x22,0x33,0x44};
unsigned char code TurnOnRedLed[4] =   {0xBA,0x03,0x40,0x01};
unsigned char code TurnOffRedLed[4] = {0xBA,0x03,0x40,0x00};

unsigned char g_ucReceBuf[21];
unsigned char g_ucReceNum;
unsigned char g_ucWatchTime;
unsigned char g_ucCardType;
char g_cStatus;
char g_cErr;

bit   g_bReceOver;
bit   g_bReceReady;
bit   g_bTimeOut;

void main()
{
     InitializeSystem();

     while(1)
     {

         while (!CARDIN)
         {
              g_cErr = 0;

//Get the unique serial number of Mifare Card
              SendCom(SelectCard);                              //
              StartTime(8);                                     //waitting until receive response from SL013 or over 80ms
              while (!g_bReceOver && !g_bTimeOut);              //
              StopTime();                                       //
              if ((g_ucReceBuf[2]!=0x01) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
              {   continue;   }

              if (g_ucReceBuf[1] == 8)
             {
                 g_ucCardType = g_ucReceBuf[8];
             }
             else
             {
                 g_ucCardType = g_ucReceBuf[11];
             }

             switch(g_ucCardType)
              {
                  case 1://Mifare_Std_1K
                      g_cStatus = ReadWriteMifareStd( );
                      if (g_cStatus != true)
                      {    g_cErr = 3;    }
                      break;
                  case 2://Mifare_Pro
                      g_cErr = 4;
                      break;
                  case 3://Mifare_UltraLight
                      g_cStatus = ReadWriteUltralight( );
                      if (g_cStatus != true)
                      {    g_cErr = 3;    }
                      break;
                  case 4://Mifare_Std_4K
                      g_cStatus = ReadWriteMifareStd( );
                      if (g_cStatus != true)
                      {    g_cErr = 3;    }
                      break;
                  case 5://Mifare_ProX
                      g_cErr = 4;
                      break;
                  case 6://Mifare_DesFire
                      g_cErr = 4;
                      break;
                 default:
                     g_cErr = 3;
                      break;
              }

//Glare Red_Led to indicate working ok
              if (g_cErr == 0)
              {
              SendCom(TurnOnRedLed);
                  StartTime(8);
                  while (!g_bReceOver && !g_bTimeOut);
                  StopTime();

                  StartTime(20);
                  while (!g_bTimeOut);
                  StopTime();

                  SendCom(TurnOffRedLed);
                  StartTime(8);
                  while (!g_bReceOver && !g_bTimeOut);
                  StopTime();
              }
         }
    }
}

////////////////////////////////////////////////////////////
char ReadWriteUltralight(void)
{

//Write data to page5 of UltraLight
    SendCom(WriteULPage5);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x11) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//read data from page5 of UltraLight
    SendCom(ReadULPage5);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x10) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Compare read data with written data
    if (memcmp(&WriteULPage5[4], &g_ucReceBuf[4], 4) != 0 )
    {    return false;   }
    else
    {    return true;   }
}

////////////////////////////////////////////////////////////
char ReadWriteMifareStd(void)
{
    long lPurseValue;

//Verify password of sector0
    SendCom(LoginSector0);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x02) || (g_ucReceBuf[3]!=2) || g_bTimeOut)
    {    return false;   }

//Write data to block1
    SendCom(WriteBlock1);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x04) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }
    if (memcmp(&WriteBlock1[4], &g_ucReceBuf[4], 16) != 0)
    {    return false;   }

//Read data from block1
    SendCom(ReadBlock1);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x03) ||(g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Compare read data with written data
    if (memcmp(&WriteBlock1[4], &g_ucReceBuf[4], 16) != 0)
    {    return false;   }

//Verify password of sector1
    SendCom(LoginSector1);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x02) || (g_ucReceBuf[3]!=2) || g_bTimeOut)
    {    return false;   }

//Initialize block4 to one purse, and value = 0x01000000
    SendCom(InitializeValue);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x06) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }
    if (memcmp(&InitializeValue[4], &g_ucReceBuf[4], 4) != 0)
    {    return false;   }

//Increment
    SendCom(IncrementValue);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x08) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Decrement
    SendCom(DecrementValue);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x09) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Backup purse to blcok5
    SendCom(CopyValue);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x0A) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Read purse value from blcok5
    SendCom(ReadValue);
    StartTime(8);
    while (!g_bReceOver && !g_bTimeOut);
    StopTime();
    if ((g_ucReceBuf[2]!=0x05) || (g_ucReceBuf[3]!=0) || g_bTimeOut)
    {    return false;   }

//Check value
    lPurseValue = g_ucReceBuf[7]*0x1000000 + g_ucReceBuf[6]*0x10000 + g_ucReceBuf[5]*0x100 + g_ucReceBuf[4];
    if (lPurseValue != 0x01000000 + 0x20000000 - 0x00000003)
    {    return false;   }
    else
    {    return true;   }

}

////////////////////////////////////////////////////////////
void InitializeSystem()
{
    TMOD &= 0x0F;
    TMOD |= 0x21;
    PCON |= 0x80;
    SCON = 0x50;
    TH1 = TL1 = BOUND115200;
    g_ucReceNum = 0;
    g_bReceOver = 0;
    g_bReceReady = 0;
    TR1   = 1;
    IE   |= 0x90;
}

////////////////////////////////////////////////////////////
void StartTime(unsigned int _MS)
{
    TH0 = (unsigned char)((TIME0_10ms>>8)&0xFF);
    TL0 = (unsigned char)(TIME0_10ms&0xFF);
    g_ucWatchTime = _MS;
    g_bTimeOut = 0;
    ET0 = 1;
    TR0 = 1;
}

////////////////////////////////////////////////////////////
time0_int () interrupt 1 using 1
{
    TH0 = (unsigned char)((TIME0_10ms>>8) & 0xFF);
    TL0 = (unsigned char)(TIME0_10ms & 0xFF);
    if (g_ucWatchTime--==0)
    {    g_bTimeOut = 1;    }
}

////////////////////////////////////////////////////////////
void StopTime()
{
    ET0 = 0;
    TR0 = 0;
}

////////////////////////////////////////////////////////////
//Send command to SL025
////////////////////////////////////////////////////////////
void SendCom(unsigned char *g_cCommand)
{
     unsigned char i,chkdata,sendleg;

     ES = 0;
     sendleg = *(g_cCommand+1) + 1;

     chkdata = 0;
     for(i=0; i<sendleg; i++)
     {
          chkdata ^= *(g_cCommand+i);

          TI = 0;
          SBUF = *(g_cCommand+i);
          while(!TI);
     }

     TI = 0;
     SBUF = chkdata;
     while (!TI);
     TI = 0;

     g_bReceReady = 1;
     g_bReceOver = 0;
     ES = 1;
}

/////////////////////////////////////////////////////////////////////
//Get result from SL025
/////////////////////////////////////////////////////////////////////
seri_int () interrupt 4 using 1
{
   unsigned char i,j;
   unsigned char rece_data = SBUF;
   unsigned char verify = 0;

   if(RI)
   {
       RI = 0;
       if (g_bReceReady)
       {
           switch (rece_data)
           {
               case 0xBD:
                    g_bReceReady = 0;
                    g_bReceOver = 0;
                    g_ucReceNum = 0;
                    g_ucReceBuf[0] = 0xBD;
                    g_ucReceBuf[1] = 0;
                    break;
               default:
                    g_ucReceNum++;
                    break;
           }
       }
       else
       {
           i = ++g_ucReceNum;
           g_ucReceBuf[i] = rece_data;
      if (g_ucReceBuf[1] == g_ucReceNum - 1)
      {
          for (j=0; j<g_ucReceNum+1; j++)
               {   verify ^= g_ucReceBuf[j];    }
               g_bReceOver = 1;
               ES = 0;
           }
           if (g_ucReceNum > sizeof(g_ucReceBuf))
           {
               g_bReceOver = 0;
               g_ucReceNum = 0;
           }
        }
    }

    if(TI)
    {

TI = 0;
}
}

RFID Products Shop

RFID Module interface ARM Microcontroller & C Source code examples

2011-06-15T22:52:00.000-07:00

RFID Module interface ARM Microcontroller & C Source code example

////////////////////////////////////////////////////////////
//Test SL025x
//ARM C source code
//LM3S600(6MHz) + EWARM 5.30
////////////////////////////////////////////////////////////
#include "hw_types.h"
#include "hw_memmap.h"
#include "hw_uart.h"
#include "hw_ints.h"
#include "string.h"
#include "sysctl.h"
#include "gpio.h"
#include "systick.h"
#include "interrupt.h"
#include "uart.h"

//============================================
//   Uart bound define
//============================================
#define BOUND4800         4800
#define BOUND9600         9600
#define BOUND14400        14400
#define BOUND19200        19200
#define BOUND28800        28800
#define BOUND38400        38400
#define BOUND57600        57600
#define BOUND115200       115200

//============================================
//   Uart Status define
//============================================
#define UARTSTATUS_FREE    0
#define UARTSTATUS_TX      1
#define UARTSTATUS_TXSUCC 2
#define UARTSTATUS_RXSUCC 3
#define UARTSTATUS_RXERR   4

//============================================
// Command List, preamble + length + command
//============================================
const unsigned char __packed SelectCard[]=      {0xBA,0x02,0x01 };
const unsigned char __packed LoginSector0[]=    {0xBA,0x0A,0x02,0x00,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char __packed LoginSector1[]=    {0xBA,0x0A,0x02,0x01,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char __packed ReadBlock1[]=      {0xBA,0x03,0x03,0x01};
const unsigned char __packed WriteBlock1[]=     {0xBA,0x13,0x04,0x01,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
const unsigned char __packed ReadValue[]=       {0xBA,0x03,0x05,0x05};
const unsigned char __packed InitializeValue[]=   {0xBA,0x07,0x06,0x04,0x00,0x00,0x00,0x01};
const unsigned char __packed IncrementValue[]= {0xBA,0x07,0x08,0x04,0x00,0x00,0x00,0x20};
const unsigned char __packed DecrementValue[]= {0xBA,0x07,0x09,0x04,0x03,0x00,0x00,0x00};
const unsigned char __packed CopyValue[]=       {0xBA,0x04,0x0A,0x04,0x05};
const unsigned char __packed ReadULPage5[]=     {0xBA,0x03,0x10,0x05};
const unsigned char __packed WriteULPage5[]=    {0xBA,0x07,0x11,0x05,0x11,0x22,0x33,0x44};
const unsigned char __packed TurnOnRedLed[]=    {0xBA,0x03,0x40,0x01};
const unsigned char __packed TurnOffRedLed[]=   {0xBA,0x03,0x40,0x00};

//============================================
// global variable define
//============================================
unsigned char g_cCardType;
unsigned long int g_iTimer;
unsigned char g_bOverTime;
unsigned char g_cUartTxCnt;
unsigned char g_cUartTxDataLen;
unsigned char *g_pUartTxDat;
unsigned char g_cUartTxCheckSum;
unsigned char g_cUartRxCnt;
unsigned char g_cUartRxBuf[60];
unsigned char g_cUartStatus;

//============================================
// i/o port define
//============================================
#define CARDIN_SL025 GPIO_PORTD_BASE,GPIO_PIN_2

//============================================
// procedure define
//============================================
void InitializeSystem();
void Start_Time(unsigned long int ms);
void Stop_Time();
void Test_SL025x();

void main()
{ InitializeSystem();
g_iTimer=0;
while(1) Test_SL025x();
}

//============================================
//   system clock interrupt procedure
//============================================
void SysTickIntHandler(void)
{ if(g_iTimer!=0)
{ g_iTimer--;
    if(g_iTimer==0) g_bOverTime=1;
}
}

//============================================
// initialize system hardware config
// system clock,uart0
//============================================
void InitializeSystem()
{
//init sysclock
//period=1ms
SysCtlClockSet(SYSCTL_SYSDIV_4|SYSCTL_USE_PLL|SYSCTL_OSC_MAIN|SYSCTL_XTAL_6MHZ);
SysTickPeriodSet(SysCtlClockGet()/1000);
SysTickEnable();
SysTickIntEnable();
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);

//CARD_IN PD2
GPIODirModeSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_DIR_MODE_IN);
GPIOPadConfigSet(GPIO_PORTD_BASE,GPIO_PIN_2,GPIO_STRENGTH_2MA,GPIO_PIN_TYPE_STD_WPU);

//init Uart
//baud=115200
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
GPIOPinTypeUART(GPIO_PORTA_BASE,GPIO_PIN_0|GPIO_PIN_1);
UARTDisable(UART0_BASE);
UARTIntClear(UART0_BASE,UART_INT_OE|UART_INT_BE|UART_INT_PE|UART_INT_FE|UART_INT_RT|UART_INT_TX|UART_INT_RX);
UARTIntDisable(UART0_BASE,UART_INT_OE|UART_INT_BE|UART_INT_PE|UART_INT_FE|UART_INT_RT|UART_INT_TX|UART_INT_RX);
UARTConfigSetExpClk(UART0_BASE,SysCtlClockGet(),BOUND115200,(UART_CONFIG_WLEN_8|UART_CONFIG_STOP_ONE|UART_CONFIG_PAR_NONE));
UARTFIFOLevelSet(UART0_BASE,UART_FIFO_TX1_8,UART_FIFO_RX1_8);
HWREG(UART0_BASE+UART_O_LCRH) &= ~(UART_LCRH_FEN);
UARTIntEnable(UART0_BASE,UART_INT_RX|UART_INT_TX);
IntEnable(INT_UART0);
g_cUartStatus=UARTSTATUS_FREE;
g_cUartRxCnt=0;

//interrupt enable
IntMasterEnable();
}

//============================================
// start timer
//============================================
void Start_Time(unsigned long int ms)
{ g_iTimer=ms;
g_bOverTime=0;
}

//============================================
// stop timer
//============================================
void Stop_Time()
{ g_iTimer=0;
}

void UARTISR_TX025x()
{ unsigned char tmp;
if(g_cUartTxCnt==g_cUartTxDataLen)
{ if(g_cUartStatus==UARTSTATUS_TX)
    { g_cUartStatus=UARTSTATUS_TXSUCC;
      g_cUartRxCnt=0;
      UARTCharPutNonBlocking(UART0_BASE,g_cUartTxCheckSum);
    }
}
else
{ tmp=g_pUartTxDat[g_cUartTxCnt];
    g_cUartTxCheckSum=g_cUartTxCheckSum^tmp;
    g_cUartTxCnt++;
    UARTCharPutNonBlocking(UART0_BASE,tmp);
}
}

void UARTISR_RX025x(unsigned char dat)
{ unsigned char CheckSum;
unsigned char counter;
g_cUartRxBuf[g_cUartRxCnt]=dat;
g_cUartRxCnt++;
if(g_cUartRxCnt==g_cUartRxBuf[1]+2)
{ CheckSum=0;
    for(counter=0;counter<g_cUartRxCnt;counter++) CheckSum=CheckSum^g_cUartRxBuf[counter];
    if(CheckSum==0) g_cUartStatus=UARTSTATUS_RXSUCC;
    else g_cUartStatus=UARTSTATUS_RXERR;
}
}

void UART0_ISR(void)
{ unsigned long flag_int;
unsigned char tmp;
flag_int=UARTIntStatus(UART0_BASE,true);
UARTIntClear(UART0_BASE,flag_int);
if((flag_int&UART_INT_TX)==UART_INT_TX) UARTISR_TX025x();
if((flag_int&UART_INT_RX)==UART_INT_RX)
{ tmp=UARTCharGetNonBlocking(UART0_BASE);
    UARTISR_RX025x(tmp);
}
}

//============================================
// send buffer by uart0
//============================================
void SendBuf_UART(unsigned char *dat,unsigned char len)
{ g_cUartStatus=UARTSTATUS_TX;
g_pUartTxDat=dat;
g_cUartTxDataLen=len;
g_cUartTxCnt=0;
g_cUartTxCheckSum=0;
UARTISR_TX025x();
}

//============================================
// SL025x1 test procedure
//============================================
void Test_SL025x()
{
#define RCVCMD_SL025x g_cUartRxBuf[2]
#define RCVSTA_SL025x g_cUartRxBuf[3]
unsigned long int lPurseValue;
unsigned char g_cErr;
g_cCardType=0xff;

if((GPIOPinRead(CARDIN_SL025)&GPIO_PIN_2)==GPIO_PIN_2) return;

//Get the unique serial number of Mifare Card
SendBuf_UART((unsigned char *)(SelectCard),sizeof(SelectCard));
Start_Time(300);
while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
Stop_Time();
if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x01)||(RCVSTA_SL025x!=0)) return;
g_cCardType=g_cUartRxBuf[g_cUartRxBuf[1]];

switch(g_cCardType)
{
    case 1:      //Mifare 1K
    case 4:      //Mifare 4K
      //Verify password of sector0
      SendBuf_UART((unsigned char *)(LoginSector0),sizeof(LoginSector0));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;

      //Write data to block1
      SendBuf_UART((unsigned char *)(WriteBlock1),sizeof(WriteBlock1));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x04)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cUartRxBuf[4],16)!=0) return;

      //Read data from block1
      SendBuf_UART((unsigned char *)(ReadBlock1),sizeof(ReadBlock1));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x03)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cUartRxBuf[4],16)!=0) return;

      //Verify password of sector1
      SendBuf_UART((unsigned char *)(LoginSector1),sizeof(LoginSector1));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;

      //Initialize block4 to one purse, and value = 0x01000000
      SendBuf_UART((unsigned char *)(InitializeValue),sizeof(InitializeValue));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x06)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&InitializeValue[4],&g_cUartRxBuf[4],4)!=0) return;

      //Increment
      SendBuf_UART((unsigned char *)(IncrementValue),sizeof(IncrementValue));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x08)||(RCVSTA_SL025x!=0)) return;

      //Decrement
      SendBuf_UART((unsigned char *)(DecrementValue),sizeof(DecrementValue));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x09)||(RCVSTA_SL025x!=0)) return;

      //Backup purse to blcok5
      SendBuf_UART((unsigned char *)(CopyValue),sizeof(CopyValue));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x0a)||(RCVSTA_SL025x!=0)) return;

      //Read purse value from blcok5
      SendBuf_UART((unsigned char *)(ReadValue),sizeof(ReadValue));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x05)||(RCVSTA_SL025x!=0)) return;

      //Check value
      lPurseValue=g_cUartRxBuf[7];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[6];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[5];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[4];
      if(lPurseValue!=0x01000000+0x20000000-0x00000003) return;
      g_cErr=0;
      break;


    case 3:      //Mifare_UltraLight
      SendBuf_UART((unsigned char *)(WriteULPage5),sizeof(WriteULPage5));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x11)||(RCVSTA_SL025x!=0)) return;
      SendBuf_UART((unsigned char *)(ReadULPage5),sizeof(ReadULPage5));
      Start_Time(300);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x10)||(RCVSTA_SL025x!=0)) return;
      if (memcmp(&WriteULPage5[4],&g_cUartRxBuf[4],4)!=0) return;
      g_cErr=0;
      break;


    case 2:      //Mifare_Pro
    case 5:      //Mifare_ProX
    case 6:      //Mifare_DesFire
      g_cErr=4;
      break;


    default:
      g_cErr=3;
      break;
}
if(g_cErr!=0) return;

//Glare Red_Led to indicate working ok
SendBuf_UART((unsigned char *)(TurnOnRedLed),sizeof(TurnOnRedLed));
Start_Time(300);
while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
Stop_Time();
Start_Time(300);
while(g_bOverTime==0);
Stop_Time();
SendBuf_UART((unsigned char *)(TurnOffRedLed),sizeof(TurnOffRedLed));
Start_Time(300);
while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
Stop_Time();
}

RFID Products Shop

RFID Module interface AVR Microcontroller & C Source code examples

2011-06-15T22:49:00.000-07:00

RFID Module interface AVR Microcontroller & C Source code examples

////////////////////////////////////////////////////////////

//Test SL025x

//AVR C source code

//ATmega16(7.3728MHz) + EWAVR 5.20

////////////////////////////////////////////////////////////
#include <ioavr.h>
#include <intrinsics.h>
#include <avr_macros.h>
#include <iomacro.h>
#include <string.h>

//============================================

// oscillator define

//============================================

#define OSC 7372800L

//============================================

// Uart bound define

//============================================

#define BOUND4800         4800
#define BOUND9600         9600
#define BOUND14400        14400
#define BOUND19200        19200
#define BOUND28800        28800
#define BOUND38400        38400
#define BOUND57600        57600
#define BOUND115200       115200

//============================================

// Pin define

//============================================

#define CARDIN PIND_Bit2

//============================================

// Uart Status define

//============================================

#define UARTSTATUS_FREE 0
#define UARTSTATUS_TX 1
#define UARTSTATUS_TXSUCC 2
#define UARTSTATUS_RXSUCC 3
#define UARTSTATUS_RXERR 4

//============================================

// global variable define

//============================================

unsigned char g_cCardType;
unsigned long int g_iTimer;
unsigned char g_bOverTime;
unsigned char g_cUartTxCnt;
unsigned char g_cUartTxDataLen;
unsigned char *g_pUartTxDat;
unsigned char g_cUartTxCheckSum;
unsigned char g_cUartRxCnt;
unsigned char g_cUartRxBuf[60];
unsigned char g_cUartStatus;

//============================================

// Command List, preamble + length + command

//============================================

const unsigned char SelectCard[]       ={0xBA,0x02,0x01 };
const unsigned char LoginSector0[]     ={0xBA,0x0A,0x02,0x00,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char LoginSector1[]     ={0xBA,0x0A,0x02,0x01,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char ReadBlock1[]       ={0xBA,0x03,0x03,0x01};
const unsigned char WriteBlock1[]      ={0xBA,0x13,0x04,0x01,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
const unsigned char ReadValue[]        ={0xBA,0x03,0x05,0x05};
const unsigned char InitializeValue[] ={0xBA,0x07,0x06,0x04,0x00,0x00,0x00,0x01};
const unsigned char IncrementValue[]   ={0xBA,0x07,0x08,0x04,0x00,0x00,0x00,0x20};
const unsigned char DecrementValue[]   ={0xBA,0x07,0x09,0x04,0x03,0x00,0x00,0x00};
const unsigned char CopyValue[]        ={0xBA,0x04,0x0A,0x04,0x05};
const unsigned char ReadULPage5[]      ={0xBA,0x03,0x10,0x05};
const unsigned char WriteULPage5[]     ={0xBA,0x07,0x11,0x05,0x11,0x22,0x33,0x44};
const unsigned char TurnOnRedLed[]     ={0xBA,0x03,0x40,0x01};
const unsigned char TurnOffRedLed[]    ={0xBA,0x03,0x40,0x00};

//============================================

// procedure define

//============================================

void Init_Hardware();
void Start_Time(unsigned long int ms);
void Stop_Time();
void UARTISR_TX();
void SendBuf_UART(unsigned char *dat,unsigned char len);
void Test_SL025x();

void main()
{
Init_Hardware();
g_iTimer=0;
while(1) Test_SL025x();
}

//============================================

// initialize system hardware config

// timer,uart,port

//============================================

void Init_Hardware()
{
__disable_interrupt();
DDRD=0x00;PORTD=0xff;
TCCR0=0;
TCNT0=184;
TIMSK_TOIE0=1;
TCCR0=0x05;
UCSRB=0xd8;
UBRRH=0x00;
UBRRL=OSC/16/BOUND115200-1;
g_cUartRxCnt=0;
g_cUartStatus=UARTSTATUS_FREE;
__enable_interrupt();
}

//============================================

// start timer

//============================================

void Start_Time(unsigned long int ms)
{
g_iTimer=ms;
g_bOverTime=0;
}

//============================================

// stop timer

//============================================

void Stop_Time()
{
g_iTimer=0;
}

void UARTISR_TX()
{
unsigned char tmp;
if(g_cUartTxCnt==g_cUartTxDataLen)
{
    if(g_cUartStatus==UARTSTATUS_TX)
    {
      g_cUartStatus=UARTSTATUS_TXSUCC;
      g_cUartRxCnt=0;
      UDR=g_cUartTxCheckSum;
    }
}
else
{
    tmp=g_pUartTxDat[g_cUartTxCnt];
    g_cUartTxCheckSum=g_cUartTxCheckSum^tmp;
    g_cUartTxCnt++;
    UDR=tmp;
}
}

//============================================

// send buffer by uart

//============================================

void SendBuf_UART(unsigned char *dat,unsigned char len)
{
g_cUartStatus=UARTSTATUS_TX;
g_pUartTxDat=dat;
g_cUartTxDataLen=len;
g_cUartTxCnt=0;
g_cUartTxCheckSum=0;
UARTISR_TX();
}

//============================================

// timer0 overflow interrupt

// 10ms

//============================================

#pragma vector = TIMER0_OVF_vect
__interrupt void Timer0_ISR(void)
{
TCNT0=184;
if(g_iTimer!=0)
{
g_iTimer--;
if(g_iTimer==0) g_bOverTime=1;
}
}

//============================================

// uart rx interrupt

//============================================

#pragma vector = USART_RXC_vect
__interrupt void UART_ISR_RXC(void)
{
unsigned char CheckSum;
unsigned char counter;
g_cUartRxBuf[g_cUartRxCnt]=UDR;
g_cUartRxCnt++;
if(g_cUartRxCnt==g_cUartRxBuf[1]+2)
{
    CheckSum=0;
    for(counter=0;counter<g_cUartRxCnt;counter++) CheckSum=CheckSum^g_cUartRxBuf[counter];
    if(CheckSum==0) g_cUartStatus=UARTSTATUS_RXSUCC;
    else g_cUartStatus=UARTSTATUS_RXERR;
}
}

//============================================

// uart tx interrupt

//============================================

#pragma vector = USART_TXC_vect
__interrupt void UART_ISR_TXC(void)
{
UARTISR_TX();
}

void Test_SL025x()
{
#define RCVCMD_SL025x g_cUartRxBuf[2]
#define RCVSTA_SL025x g_cUartRxBuf[3]
unsigned long int lPurseValue;
g_cCardType=0xff;

if(CARDIN!=0) return;

SendBuf_UART((unsigned char *)(SelectCard),sizeof(SelectCard));
Start_Time(30);
while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
Stop_Time();
if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x01)||(RCVSTA_SL025x!=0)) return;
g_cCardType=g_cUartRxBuf[g_cUartRxBuf[1]];

switch(g_cCardType)
{
    case 1:   //Mifare 1k
    case 4:   //Mifare 4k
      //Verify password of sector0
      SendBuf_UART((unsigned char *)(LoginSector0),sizeof(LoginSector0));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;

      //Write data to block1
      SendBuf_UART((unsigned char *)(WriteBlock1),sizeof(WriteBlock1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x04)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cUartRxBuf[4],16)!=0) return;

      //Read data from block1
      SendBuf_UART((unsigned char *)(ReadBlock1),sizeof(ReadBlock1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x03)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cUartRxBuf[4],16)!=0) return;

      //Verify password of sector1
      SendBuf_UART((unsigned char *)(LoginSector1),sizeof(LoginSector1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;

      //Initialize block4 to one purse, and value = 0x01000000
      SendBuf_UART((unsigned char *)(InitializeValue),sizeof(InitializeValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x06)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&InitializeValue[4],&g_cUartRxBuf[4],4)!=0) return;

      //Increment
      SendBuf_UART((unsigned char *)(IncrementValue),sizeof(IncrementValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x08)||(RCVSTA_SL025x!=0)) return;

      //Decrement
      SendBuf_UART((unsigned char *)(DecrementValue),sizeof(DecrementValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x09)||(RCVSTA_SL025x!=0)) return;

      //Backup purse to blcok5
      SendBuf_UART((unsigned char *)(CopyValue),sizeof(CopyValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x0a)||(RCVSTA_SL025x!=0)) return;

      //Read purse value from blcok5
      SendBuf_UART((unsigned char *)(ReadValue),sizeof(ReadValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x05)||(RCVSTA_SL025x!=0)) return;

      //Check value
      lPurseValue=g_cUartRxBuf[7];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[6];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[5];
      lPurseValue=(lPurseValue<<8)+g_cUartRxBuf[4];
      if(lPurseValue!=0x01000000+0x20000000-0x00000003) return;

      //Glare Red_Led to indicate working ok
      SendBuf_UART((unsigned char *)(TurnOnRedLed),sizeof(TurnOnRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      Start_Time(30);
      while(g_bOverTime==0);
      Stop_Time();
      SendBuf_UART((unsigned char *)(TurnOffRedLed),sizeof(TurnOffRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      break;


    case 3:   //Mifare Ultralight
      SendBuf_UART((unsigned char *)(WriteULPage5),sizeof(WriteULPage5));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x11)||(RCVSTA_SL025x!=0)) return;
      SendBuf_UART((unsigned char *)(ReadULPage5),sizeof(ReadULPage5));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x10)||(RCVSTA_SL025x!=0)) return;
      if (memcmp(&WriteULPage5[4],&g_cUartRxBuf[4],4)!=0) return;

      //Glare Red_Led to indicate working ok
      SendBuf_UART((unsigned char *)(TurnOnRedLed),sizeof(TurnOnRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      Start_Time(30);
      while(g_bOverTime==0);
      Stop_Time();
      SendBuf_UART((unsigned char *)(TurnOffRedLed),sizeof(TurnOffRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Stop_Time();
      break;

    default:
      break;
}
}

RFID Products Shop

RFID Module interface Microchip PIC Microcontroller & C Source code examples

2011-06-15T22:36:00.000-07:00

RFID Module interface with Microchip PIC Microcontroller

//============================================

//Test RFID Module

//PIC C source code

//PIC16F887(8MHz) + PICC 9.70

//============================================

#include <htc.h>
#include <pic16f887.h>
#include <string.h>

__CONFIG(DEBUGEN&LVPDIS&FCMEN&IESOEN&BOREN&UNPROTECT&DUNPROTECT&MCLREN&PWRTEN&WDTDIS&INTIO);

//============================================

// PIN define

//============================================

#define RX_PIN TRISC7
#define TX_PIN TRISC6
#define Buzzer RB2
#define CARDIN_SL025x RC0

//============================================

// Uart status words define

//============================================

#define UARTSTATUS_FREE 0
#define UARTSTATUS_TX 1
#define UARTSTATUS_TXSUCC 2
#define UARTSTATUS_RXSUCC 3
#define UARTSTATUS_RXERR 4

//============================================

// Card type define

//============================================

#define CARDTYPE_S50 0
#define CARDTYPE_S70 1
#define CARDTYPE_ProX 2
#define CARDTYPE_Pro 3
#define CARDTYPE_UL 4
#define CARDTYPE_DES 5
#define CARDTYPE_TAG 6
#define CARDTYPE_ICODE 7

//============================================

// global variable define

//============================================

bank1 unsigned int g_iTimer;
bank1 unsigned char g_cTimer_Buzzer;
unsigned char g_bOverTime;
bit g_bUartTxHead;
bit g_bUartRxHead;
const unsigned char *g_pUartTxDat;
unsigned char g_cUartTxCheckSum;
unsigned char g_cUartRxCnt;
unsigned char g_cUartStatus;
bank1 unsigned char g_cRxBuf[40];
bank1 unsigned char g_cUartTxCnt;
bank1 unsigned char g_cUartTxDataLen;
bank1 unsigned char g_cCardType;

//============================================

// Command List, preamble + length + command

//============================================

const unsigned char SelectCard[] = {0xBA,0x02,0x01 };
const unsigned char LoginSector0[] = {0xBA,0x0A,0x02,0x00,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char LoginSector1[] = {0xBA,0x0A,0x02,0x01,0xAA,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
const unsigned char ReadBlock1[] = {0xBA,0x03,0x03,0x01};
const unsigned char WriteBlock1[] = {0xBA,0x13,0x04,0x01,0x00,0x11,0x22,0x33,0x44,0x55,0x66,0x77,0x88,0x99,0xAA,0xBB,0xCC,0xDD,0xEE,0xFF};
const unsigned char ReadValue[] = {0xBA,0x03,0x05,0x05};
const unsigned char InitializeValue[] = {0xBA,0x07,0x06,0x04,0x00,0x00,0x00,0x01};
const unsigned char IncrementValue[] = {0xBA,0x07,0x08,0x04,0x00,0x00,0x00,0x20};
const unsigned char DecrementValue[] = {0xBA,0x07,0x09,0x04,0x03,0x00,0x00,0x00};
const unsigned char CopyValue[] = {0xBA,0x04,0x0A,0x04,0x05};
const unsigned char ReadULPage5[] = {0xBA,0x03,0x10,0x05};
const unsigned char WriteULPage5[] = {0xBA,0x07,0x11,0x05,0x11,0x22,0x33,0x44};
const unsigned char TurnOnRedLed[] = {0xBA,0x03,0x40,0x01};
const unsigned char TurnOffRedLed[] = {0xBA,0x03,0x40,0x00};

//============================================

// procedure define

//============================================

void Init_Hardware(void);
void BuzzerOn(void);
void Start_Time(unsigned int ms);
void SendBuf_UART(const unsigned char *dat,unsigned char len);
void Test_SL025x(void);

//============================================

// initialize system hardware config

// timer,uart,port

//============================================

void Init_Hardware(void)
{
OSCCON=0x71;
while(HTS==0);
ANSEL=0x00;
ANSELH=0x00;
TRISB2=0;
OPTION=0x07;
TMR0=0xb1;
T0IE=1;
RX_PIN=1;
TX_PIN=1;
Buzzer=0;
TXSTA=0x04;
RCSTA=0x90;
BAUDCTL=0x08;
SPBRG=0x10;
SPBRGH=0;
RCIE=1;
TXEN=1;
PEIE=1;
GIE=1;
}

//============================================

// interrupt service

// timer interrupt

// uart rx interrupt

//============================================

void interrupt isr(void)
{
unsigned char dat;
unsigned char CheckSum;
unsigned char counter;
if(T0IF)
{
    T0IF=0;
    TMR0=0xb1;
    if(g_iTimer!=0)
    {
      g_iTimer--;
      if(g_iTimer==0) g_bOverTime=1;
    }
    if(g_cTimer_Buzzer!=0)
    {
      g_cTimer_Buzzer--;
      if(g_cTimer_Buzzer==0) Buzzer=0;
    }
}
if(RCIF)
{
    dat=RCREG;
    {
      g_cRxBuf[g_cUartRxCnt]=dat;
      g_cUartRxCnt++;
      if(g_cUartRxCnt==g_cRxBuf[1]+2)
      {
        CheckSum=0;
        for(counter=0;counter<g_cUartRxCnt;counter++) CheckSum=CheckSum^g_cRxBuf[counter];
        if(CheckSum==0) g_cUartStatus=UARTSTATUS_RXSUCC;
        else g_cUartStatus=UARTSTATUS_RXERR;
      }
    }
}
}

//============================================

// trun on buzzer about 100mS

//============================================

void BuzzerOn(void)
{
Buzzer=1;
g_cTimer_Buzzer=10;
}

//============================================

// start timer

//============================================

void Start_Time(unsigned int ms)
{
g_iTimer=ms;
g_bOverTime=0;
}

//============================================

// send buffer by uart

//============================================

void SendBuf_UART(const unsigned char *dat,unsigned char len)
{
unsigned char tmp;
g_cUartStatus=UARTSTATUS_TX;
g_pUartTxDat=dat;
g_cUartTxDataLen=len;
g_cUartTxCnt=0;
g_cUartTxCheckSum=0;
g_bUartTxHead=0;
while(g_cUartTxCnt!=g_cUartTxDataLen)
{
    tmp=g_pUartTxDat[g_cUartTxCnt];
    g_cUartTxCheckSum=g_cUartTxCheckSum^tmp;
    g_cUartTxCnt++;
    while(TXIF==0);
    TXREG=tmp;
}
g_cUartStatus=UARTSTATUS_TXSUCC;
g_cUartRxCnt=0;
while(TXIF==0);
TXREG=g_cUartTxCheckSum;
}

#define RCVCMD_SL025x g_cRxBuf[2]
#define RCVSTA_SL025x g_cRxBuf[3]

void Test_SL025x(void)
{
unsigned long int lPurseValue;
g_cCardType=0xff;
if(CARDIN_SL025x) return;
SendBuf_UART(SelectCard,sizeof(SelectCard));
Start_Time(30);
while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x01)||(RCVSTA_SL025x!=0)) return;
if(g_cRxBuf[g_cRxBuf[1]]==1) g_cCardType=CARDTYPE_S50;
else if(g_cRxBuf[g_cRxBuf[1]]==2) g_cCardType=CARDTYPE_Pro;
else if(g_cRxBuf[g_cRxBuf[1]]==3) g_cCardType=CARDTYPE_UL;
else if(g_cRxBuf[g_cRxBuf[1]]==4) g_cCardType=CARDTYPE_S70;
else if(g_cRxBuf[g_cRxBuf[1]]==5) g_cCardType=CARDTYPE_ProX;
else if(g_cRxBuf[g_cRxBuf[1]]==6) g_cCardType=CARDTYPE_DES;
switch(g_cCardType)
{
    case CARDTYPE_S50:
    case CARDTYPE_S70:
      //Verify password of sector0
      SendBuf_UART(LoginSector0,sizeof(LoginSector0));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;
      //Write data to block1
      SendBuf_UART(WriteBlock1,sizeof(WriteBlock1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x04)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cRxBuf[4],16)!=0) return;
      //Read data from block1
      SendBuf_UART(ReadBlock1,sizeof(ReadBlock1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x03)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&WriteBlock1[4],&g_cRxBuf[4],16)!=0) return;
      //Verify password of sector1
      SendBuf_UART(LoginSector1,sizeof(LoginSector1));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x02)||(RCVSTA_SL025x!=0x02)) return;
      //Initialize block4 to one purse, and value = 0x01000000
      SendBuf_UART(InitializeValue,sizeof(InitializeValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x06)||(RCVSTA_SL025x!=0)) return;
      if(memcmp(&InitializeValue[4],&g_cRxBuf[4],4)!=0) return;
      //Increment
      SendBuf_UART(IncrementValue,sizeof(IncrementValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x08)||(RCVSTA_SL025x!=0)) return;
      //Decrement
      SendBuf_UART(DecrementValue,sizeof(DecrementValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x09)||(RCVSTA_SL025x!=0)) return;
      //Backup purse to blcok5
      SendBuf_UART(CopyValue,sizeof(CopyValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x0a)||(RCVSTA_SL025x!=0)) return;
      //Read purse value from blcok5
      SendBuf_UART(ReadValue,sizeof(ReadValue));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x05)||(RCVSTA_SL025x!=0)) return;
      //Check value
      lPurseValue=g_cRxBuf[7];
      lPurseValue=(lPurseValue<<8)+g_cRxBuf[6];
      lPurseValue=(lPurseValue<<8)+g_cRxBuf[5];
      lPurseValue=(lPurseValue<<8)+g_cRxBuf[4];
      if(lPurseValue!=0x01000000+0x20000000-0x00000003) return;
      BuzzerOn();
      //Glare Red_Led to indicate working ok
      SendBuf_UART(TurnOnRedLed,sizeof(TurnOnRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Start_Time(30);
      while(g_bOverTime==0);
      SendBuf_UART(TurnOffRedLed,sizeof(TurnOffRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      break;
    case CARDTYPE_UL:
      SendBuf_UART(WriteULPage5,sizeof(WriteULPage5));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x11)||(RCVSTA_SL025x!=0)) return;
      SendBuf_UART(ReadULPage5,sizeof(ReadULPage5));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      if((g_cUartStatus!=UARTSTATUS_RXSUCC)||(RCVCMD_SL025x!=0x10)||(RCVSTA_SL025x!=0)) return;
      if (memcmp(&WriteULPage5[4],&g_cRxBuf[4],4)!=0) return;
      BuzzerOn();
      //Glare Red_Led to indicate working ok
      SendBuf_UART(TurnOnRedLed,sizeof(TurnOnRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      Start_Time(30);
      while(g_bOverTime==0);
      SendBuf_UART(TurnOffRedLed,sizeof(TurnOffRedLed));
      Start_Time(30);
      while((g_cUartStatus!=UARTSTATUS_RXERR)&&(g_cUartStatus!=UARTSTATUS_RXSUCC)&&(g_bOverTime==0));
      break;
    default:
      break;
    }
}

void main(void)
{
Init_Hardware();
g_iTimer=0;
while(1) Test_SL025x();
}

RFID Products Shop