Smart Port RF Manual do Usuário Rev. 3.0

(1)

Smart Port RF

Manual do Usuário

(2)

ÍNDICE

1 Formas de Operação...5

2 Chamadas das Funções...5

2.1 SMPRF_OpenPort ...5

2.2 SMPRF_ClosePort...5

2.3 SMPRF_GetVersion ...6

2.4 SMPRF_SelectMifareCard ...6

2.5 SMPRF_LoginToSector ...6

2.6 SMPRF_ReadDataBlock ...7

2.7 SMPRF_WriteDataBlock...7

2.8 SMPRF_ReadValueBlock...8

2.9 SMPRF_WriteValueBlock ...8

2.10 SMPRF_WriteMasterKey...8

2.11 SMPRF_IncrementValue ...9

2.12 SMPRF_DecrementValue ...9

2.13 SMPRF_CopyValue ... 10

2.14 SMPRF_Card_Halt ... 10

2.15 SMPRF_RequestMifareCard ... 10

2.16 SMPRF_AutoLogin ... 11

2.17 SMPRF_LoginWithKeyStored... 11

2.18 SMPRF_StoreKey... 11

2.19 SMPRF_ExchangeAPDU ... 12

2.20 SMPRF_BlinkLeds... 12

2.21 SMPRF_Send_Beep ... 13

2.22 SMPRF_ChangeBaudRate ... 13

2.23 SMPRF_Reset... 13

2.24 SMPRF_ConvBase... 14

2.25 SMPRF_MSB2LSB... 14

2.26 SMPRF_ChangeProtType ... 14

3 Exemplos de Aplicações. ... 15

3.1 Exemplo de carga e chamadas utilizando o Visual C++. ... 15

3.2 Exemplo de carga e chamadas utilizando o Visual Basic 6. ... 18

4 Protocolo de Comunicação... 21

4.1 Configuração da Comunicação ... 21

4.1.1 Framing de Comunicação... 21

4.2 SET de Comandos e Status ... 22

4.2.1 Select Card ... 23

4.2.2 Login to Sector ... 23

4.2.3 Read data block ... 24

4.2.4 Write data block... 24

4.2.5 Read Value block ... 25

4.2.6 Write Value block ... 25

4.2.7 Write Master Key (Chave A)... 26

4.2.8 Increment Value ... 27

(3)

4.2.10 Copy Value ... 29

4.2.11 Card Halt. ... 29

4.2.12 Request MIFARE Card. ... 30

4.2.13 Auto Login. ... 30

4.2.14 Login With key stored... 31

4.2.15 Store Key... 31

4.2.16 Exchange APDU ... 32

4.2.17 Send_Beep ... 32

4.2.18 Change Baud Rate ... 33

4.2.19 Get Version... 33

4.2.20 Change Card Baud Rate ... 34

4.2.21 Change Detection Mode ... 35

4.2.22 Set Data Source ... 36

4.2.23 Protocol Change... 37

4.2.24 Blink Led ... 37

4.2.25 Get_Reader_Ser_Num ... 38

4.2.26 Set_Network_Addr... 38

4.2.27 Reset Reader... 39

5 Pinagem... 40

Anexo I Modelo OEM

I. Objetivo ...II

II. O que há de novo: ...II

III. Pinagem: ...II

IV. Multiponto / Ponto a Ponto ...III

IV.I Endereçamento Lógico ...III

IV.II Modo de Compatibilidade...III

IV.III

Controle de Direção RX-TX... IV

IV.IV

Enumeração em rede ... V

V. Especificações ... VII

V.I Mecânicas ... VII

V.II Elétricas... VIII

(4)

Anexo II Modelo OEM Versão EMU

I. Introdução...II

II. Forma de Operação...II

III. Interface...II

IV. Substituição do Sensor...II

V. Emulação de Padrões...III

V.I Modo Emulador 1 – Número de Série ...III

V.II Modo Emulador 2 – Dados Gravados ...III

VI. Cartão magnético trilha 2 ... IV

VI.I Formato ... IV

VI.II Diagrama dos Sinais ... IV

VII. Padrão Wiegand 26 bits ... V

VII.I Formato ... V

VII.II

Diagrama dos Sinais ... V

VIII. Código de Barras 2/5 Intercalado... VI

VIII.I

Formato ... VI

VIII.II

Diagrama dos Sinais ... VI

IX. Pinagem... VII

X. Configurações ... VIII

X.I Padrão de Interface ... VIII X.II Configuração do padrão pelo cabo ... VIII X.III Configuração do padrão através do jumper de solda ... VIII

XI. Modo de Emulação... VIII

XII. Set de Comandos Válidos ... IX

Revisões

Rev. Data Descrição Responsável

PR 18/04/2006 Liberação da Versão Preliminar Leandro

1.0 22/05/2006 Correção de erros e inserção de pinagem, e características elétricas

Leandro / Marco

2.0 27/06/2006 Correção de erros, melhoria no detalhamento dos modos de operação, criado manual para a versão EMU

Ie / Leandro

3.0 18/08/2006 Integração de todos os manuais em um único volume

(5)

1 Formas de Operação

A versão Smart port RF Standard opera por atendimento aos comandos recebidos pela porta serial.

Desta forma, quando um comando é processado, o leitor estará pronto para receber outro comando para poder executar a operação seguinte.

Esta colocação é importante para desenvolvedores acostumados a leitores com interface de emulação onde o leitor opera de forma autônoma, efetuando a leitura do número de série. Com o objetivo de se diminuir a sobrecarga de processamento, existem algumas configurações e comandos compostos.

2 Chamadas das Funções

Este capítulo detalha as funções contidas na SmartPortRF.dll, bem como suas chamadas e retornos.

Estas chamadas de funções destinam-se às pessoas que desejem desenvolver aplicações em ambiente Windows para executar operações com o leitor SmartPort RF Standard com interface serial.

Para ser compatível com C/C++, Visual Basic, Delphi e outras linguagens de programação, todas as rotinas listadas abaixo, trabalham utilizando a convenção __stdcall.

2.1 SMPRF_OpenPort

Descrição: Esta função abre e configura a porta de comunicação. Protótipo: int SMPRF_OpenPort (UINT NumPort,UINT Baud_Rate) Parâmetros de Entrada:

UINT NumPort : Número da Porta serial a ser aberta de 1 a 10.

UINT Baud_Rate: Velocidade de comunicação de 1200 a 115200 bauds

Parâmetros de Saída:

int Sendo:

0 Porta Aberta com Sucesso -1 Erro na abertura da porta serial -2 Erro de configuração de parâmetros -3 Velocidade com parâmetro inválido -7 Número de Porta inválido

2.2 SMPRF_ClosePort

Descrição: Esta função fecha a porta de comunicação. Protótipo: int SMPRF_ClosePort()

Parâmetros de Entrada:

Nenhum

(6)

2.3 SMPRF_GetVersion

Descrição: Requisita ao Leitor seu nome, versão, data e padrão de funcionamento. Protótipo: int SMPRF_GetVersion( unsigned char * Destino, unsigned char *len )

Formato da String de versão:

" CIS SmartPort-RF V:1.04.00--11/MAI/06-STD

|---1---| |---2---| |---3---| |--4--| 1- Nome do Produto = CIS SmartPort-RF 2- Versão do Firmware = V:1.04.00 3- Data de Compilação = 11/MAI/06 4- Padrão de Funcionamento = EMU

a. STD – Modo Padrão Leitura e Gravação de cartões pela porta serial b. EMU -- Modo Emulador de Padrões (Código de Barras, Trilha 02).

unsigned char * Destino, Ponteiro onde deve ser armazenado a string de versão. unsigned char *len, Ponteiro onde deve ser armazenado o tamanho da String de

versão.

Parâmetros de Saída

int Status 0 Success

-2 Erro de comunicação (TX_ERR).

2.4 SMPRF_SelectMifareCard

Descrição: Esta função verifica se existe um cartão no campo de detecção do leitor.

Caso seja detectado um cartão o número de série deste cartão e retornado em CardSrNum.

Protótipo: int SMPRF_SelectMifareCard (unsigned char * CardSrNum)

unsigned char * CardSrNum: Ponteiro para onde armazenar o número de série do cartão detectado. Caso nenhum cartão seja detectado, nenhum dado será armazenado.

int Status 0 Sucesso

-1 Cartão Não detectado -2 Erro de comunicação

2.5 SMPRF_LoginToSector

Descrição: Esta função executa o login no setor espec ífico do cartão.

Protótipo: int SMPRF_ LoginToSector (UCHAR Sector, UCHAR KeyType, UCHAR * KEY) Parâmetros de Entrada:

UCHAR Sector: Setor para executar o login

0x00 – 0x0F para cartões MIFARE 1K 0x00 – 0x27 para cartões MIFARE 4K

UCHAR KeyType: Tipo de Chave a ser utilizada chave A(0x60) ou chave B(0x61) UCHAR * KEY: Ponteiro onde se encontra a chave de autenticação (6 Bytes)

(7)

int Status 0 Sucesso 3 Falha de Login

-2 Erro de comunicação

2.6 SMPRF_ReadDataBlock

Descrição: Lê um bloco de dados de 16 bytes. Para efetuar a leitura é necessário que a operação de login no setor tenha sido realizada com sucesso.

Protótipo: int SMPRF_ ReadDataBlock (UCHAR Block, UCHAR * Data) Parâmetros de Entrada:

UCHAR Block Número do bloco a ser lido:

Exemplo: para Login no Setor 0 à blocos 0, 1, 2 ou 3 Para Login no Setor 1à blocos 4, 5, 6 ou 7 Para Login no Setor 2à blocos 8, 9,10 ou 11

UCHAR * Data Ponteiro que indica onde serão armazenados os dados lidos.

Parâmetros de Saída :

int Status 0 Sucesso 4 Falha de Leitura

2.7 SMPRF_WriteDataBlock

Descrição: Escreve num bloco de dados de 16 bytes. Para efetuar a escrita é necessário que a operação de login no setor tenha sido realizada com sucesso e que a senha utilizada tenha permissão de escrita.

Protótipo: int SMPRF_WriteDataBlock (UCHAR Block, unsigned char * Data)

UCHAR Block: Número do bloco a ser escrito:

Exemplo para Login no Setor 0 à blocos 0, 1, 2 ou 3 Para Login no Setor 1à blocos 4, 5, 6 ou 7

Para Login no Setor 2à blocos 8, 9,10 ou 11

UCHAR * Data: Ponteiro que indica onde estão armazenados os dados a serem escritos.

int Status 0 Sucesso 5 Falha de Escrita

(8)

2.8 SMPRF_ReadValueBlock

Descrição: Lê um bloco de valor (long 4 bytes). Para efetuar a leitura é necessário que a operação de login no setor tenha sido realizada com sucesso. Se o bloco requisitado não for um bloco de valor a operação não é realizada, e um erro é retornado.

Protótipo: int SMPRF_ ReadValueBlock(UCHAR Block, PLONG Value)

UCHAR Block Número do bloco a ser lido:

PLONG Value: Ponteiro que indica onde será armazenado o valor lido.

int Status 0 Sucesso 4 Falha de Leitura

14 Este não é um bloco de valor -2 Erro de comunicação

2.9 SMPRF_WriteValueBlock

Descrição: Escreve um valor (long 4 bytes) num bloco de valor. Para efetuar a escrita é necessário que a operação de login no setor tenha sido realizada com sucesso e que a senha usada tenha permissão de escrita.

Protótipo: int SMPRF_WriteValueBlock(UCHAR Block, PLONG Value)

UCHAR Block: Número do bloco a ser escrito:

PLONG Value: Ponteiro para o Valor a ser escrito.

2.10 SMPRF_WriteMasterKey

Descrição: Este comando altera a chave A (0x60) de um bloco sem alterar a chave B. Para efeitos reais, esta função deve ser utilizada nos blocos de configuração. Também é necessário que a operação de login no setor tenha sido realizada com sucesso e que a senha utilizada no login tenha permissão de escrita.

Protótipo: int SMPRF_WriteMasterKey (UCHAR Block, UCHAR * Key)

UCHAR Block Número do bloco de configuração a ser escrito: Exemplo para Login no Setor 0 à bloco 3

(9)

Para Login no Setor 1à bloco 7 Para Login no Setor 2à bloco 11 Para Login no Setor 3à bloco 15

UCHAR * Key: Ponteiro para a nova senha a se escrita (6 bytes).

2.11 SMPRF_IncrementValue

Descrição: Incrementa um valor (long 4 bytes) num bloco de valor. Para efetuar o

incremento é necessário que a operação de login no setor tenha sido realizada com sucesso, que a senha usada tenha permissão de incremento e que exista um valor gravado neste bloco.

Protótipo: int SMPRF_ IncrementValue (UCHAR Block, PLONG Value)

UCHAR Block Número do bloco a ser escrito:

Exemplo para Login no Setor 0 à blocos 0, 1 ou 2 Para Login no Setor 1à blocos 4, 5 ou 6

Para Login no Setor 2à blocos 8, 9 ou 10

PLONG Value: Ponteiro para o Valor a ser incrementado.

PLONG Value: Valor após o incremento caso a operação tenha sido bem sucedida.

2.12 SMPRF_DecrementValue

Descrição: Decrementa um valor (long 4 bytes) num bloco de valor. Para efetuar o decremento é necessário que a operação de login no setor tenha sido realizada com sucesso, que a senha usada tenha permissão para decremento e que exista um valor gravado neste bloco.

Protótipo: int SMPRF_ DecrementValue(UCHAR Block, PLONG Value)

UCHAR Block Número do bloco a ser escrito:

Exemplo para Login no Setor 0 à blocos 0, 1 ou 2 Para Login no Setor 1à blocos 4, 5 ou 6

Para Login no Setor 2à blocos 8, 9 ou 10

(10)

2.13 SMPRF_CopyValue

Descrição: Copia um valor (long 4 bytes) para outro bloco de valor.

Para efetuar a cópia é necessário que a operação de login no setor tenha sido realizada com sucesso, que a senha utilizada tenha permissão para escrita, que exista um valor (4 bytes long) gravado no bloco fonte (source) e que o bloco de destino seja do mesmo setor do bloco fonte.

Protótipo: int SMPRF_ CopyValue(UCHAR Source, UCHAR Dest)

UCHAR Source: Número do bloco a ser copiado – bloco fonte:

UCHAR Dest: Número do bloco que receberá a cópia -- bloco destino.

5 Falha de Escrita -2 Erro de comunicação

2.14 SMPRF_Card_Halt

Descrição: Encerra a comunicação com o cartão MIFARE e o coloca em estado Halt. Depois de enviado este comando, para que o cartão volte a comunicar é necessário retirá-lo do campo de ação da antena e aproximá-lo novamente.

Protótipo: int SMPRF_Card_Halt() Parâmetros de Entrada:

Nenhum

2.15 SMPRF_RequestMifareCard

Descrição: Caso haja um cartão no campo de ação do leitor, este comando retorna o ATS do cartão detectado, com este ATS é possível identificar o cartão detectado. Valores Padrões de Respostas para Cartões MIFARE® :

ATS= 0x04, 0x00 à MIFARE® 1K Standard; ATS= 0x02, 0x00 à MIFARE® 4K ; ATS= 0x44, 0x03 à MIFARE® DESFIRE ; ATS= 0x44, 0x00 à MIFARE® UltraLigth Card;

Protótipo: int SMPRF_ RequestMifareCard(unsigned char * Resp)

UCHAR *Resp: Em caso de sucesso ponteiro para onde enviar o ATS (2 bytes para cartões MIFARE®)

int Status 0 Sucesso 4 Falha de Leitura -1 Cartão Não detectado -2 Erro de comunicação

(11)

2.16 SMPRF_AutoLogin

Descrição: Função que executa o comando de “Select Mifare Card” e “Login To Sector“ juntos.

Este comando permite a implementação de um sistema mais rápido para comunicar-se com o cartão.

Protótipo: int SMPRF_AutoLogin(UCHAR Setor,UCHAR KeyType, UCHAR * Key)

Parâmetros de entrada:

UCHAR Setor – Setor onde se deseja efetuar o login.

UCHAR Key Type – Tipo de senha que será utilizada: A ou B. UCHAR * Key - Ponteiro para senha a ser utilizada.

int Sendo: 0 Sucesso. 3 Falha de Login. -1 Cartão Não detectado -2 Erro de comunicação

2.17 SMPRF_LoginWithKeyStored

Descrição: Comando para efetuar o login em um determinado setor, utilizando uma senha

previamente armazenada no leitor Smart Port RF.

Protótipo: int SMPRF_ LoginWithKeyStored(UCHAR Setor, UCHAR KeyType,

UCHAR Key_num)

UCHAR Setor – Setor onde se deseja efetuar o login. UCHAR KeyType – Tipo de senha que será utilizada A ou B.

UCHAR Key_num – Número da senha armazenada no leitor que será utilizada para efetuar o login (de 0 a 15).

int Sendo: 0 Sucesso. 3 Falha de Login. -2 Erro de comunicação

2.18 SMPRF_StoreKey

Descrição: Comando para armazenar senhas no leitor Smart Port RF. O leitor permite o

armazenamento de até 32 senhas, sendo 16 senhas A e 16 senhas B. Esta ferramenta permite implementar sistemas mais seguros, visto que em operações de login, a senha não trafega pela via de comunicação.

Protótipo: int SMPRF_ StoreKey( UCHAR KeyNum,UCHAR KeyType, UCHAR * Key)

(12)

2.19 SMPRF_ExchangeAPDU

Descrição: Função que envia comando e recebe a resposta diretamente do cartão. No leitor

Smartport RF Standard, foram implementados comandos para facilitar a comunicação com cartões Mifare 1K, 4K e Ultralight. A função SMPRF_ ExchangeAPDU deverá ser utilizada quando se deseja comunicar-se com cartões de outros modelos, como cartões tipo B, Mifare PRO, Mifare DESFIRE e outros.

Protótipo: int SMPRF_ ExchangeAPDU (UCHAR * APDU, UCHAR Len, UCHAR * RAPDU, UCHAR * RLen) Parâmetros de Entrada:

UCHAR *APDU - Comando que se deseja enviar. UCHAR Len – Tamanho do comando a ser enviado.

UCHAR *RAPDU – Ponteiro para armazenamento da resposta.

UCHAR *RLen – Ponteiro para onde armazenar o número de bytes recebidos.

int Sendo: 0 Sucesso.

-27 Time Out da Operação (cartão não respondeu) -2 Erro de comunicação

2.20 SMPRF_BlinkLeds

Descrição: Função para piscar os leds do leitor. Você pode piscar um único led ou os dois

(juntos ou intercalados). Também consegue determinar o período entre as piscadas.

Protótipo: int SMPRF_ BlinkLeds(UCHAR Mask, UCHAR Interval)

UCHAR Mask – Bit 0 à Led Verde ON=1 / Off=0 Bit 1 à Led Vermelho ON=1 / Off=0 Bit 3 à Piscar Alternado Sim=1 / Não =0

UCHAR Interval – Intervalos e duração da piscada (de 1 a 255) em valores múltiplos de 10ms. Este valor é utilizado para ambos os Leds

=0 Não Pisca

=1 Pisca a cada 10ms =5 Pisca a cada 50ms =22 Pisca a cada 220ms =100 Pisca a cada 1s

Para apagar todos os leds enviar o comando com todos os parâmetros zerados.

(13)

2.21 SMPRF_Send_Beep

Descrição: Função envia uma solicitação para soar o buzzer x vezes. Protótipo: int SMPRF_Send_Beep(UCHAR BeepNum)

UCHAR BeepNum – Número de vezes que o beep será emitido de 1 a 15 beeps.

2.22 SMPRF_ChangeBaudRate

Descrição: Função para alterar a velocidade de comunicação serial (entre o Host e o leitor).

A velocidade de comunicação será gravada na memória do leitor e passará ser a velocidade default, ou seja caso o leitor seja desligado e ligado a velocidade será sempre a ultima velocidade programada por este comando,até que o leitor receba outro comando de alteração de baud rate.

Protótipo: int SMPRF_ ChangeBaudRate(UINT BaudRate)

UINT BaudRate – Valor do Baud Rate. 0x01 — 1200 bps 0x02 — 2400 bps 0x03 — 4800 bps 0x04 — 9600 bps 0x05 — 14400 bps 0x06 — 19200 bps 0x07 — 38400 bps 0x08 — 57600 bps 0x09 — 115200 bps Parâmetros de Saída:

35 Baud Rate não suportado -2 Erro de comunicação

2.23 SMPRF_Reset

Descrição: Função que reinicia o leitor. Protótipo: int SMPRF_ Reset()

Nenhum

(14)

2.24 SMPRF_ConvBase

Descrição: Função implementada na própria DLL para converter um valor longo de uma base

numérica para uma string na base numérica requisitada. Bases válidas de 2 a 16.

Protótipo: int SMPRF_ ConvBase( ULONG value, char* Result,char bases )

ULONG value - Valor que deverá ser convertido.

char* Result – Ponteiro para o local onde ser armazenado a string convertida. char bases – Base número para o qual o valor deverá ser convertido.

int Sendo: 0 Sucesso

-1 Base fora da faixa. -2 Erro de comunicação

2.25 SMPRF_MSB2LSB

Descrição: Função implementada na própria DLL que inverte a ordem dos bytes de um valor

longo desta forma converte o formato "Little Endian" para "Big Endian" e vice-versa.

Base Address+0 = Byte0 à Base Address+0 = Byte3 Base Address+1 = Byte1 à Base Address+1 = Byte2 Base Address+2 = Byte2 à Base Address+2 = Byte1 Base Address+3 = Byte3 à Base Address+3 = Byte0

Protótipo: void SMPRF_MSB2LSB(ULONG *Origem, ULONG *Destino)

ULONG * Origem – Dado a ser invertido.

ULONG *Destino – Ponteiro para o local onde o valor invertido deverá ser armazenado.

Nenhum

2.26 SMPRF_ChangeProtType

Descrição: Função que altera o protocolo de comunicação entre o cartão e o leitor. Você

poderá selecionar entre cartão tipo A ou cartão tipo B.

Nota: As comunicações com cartões que ut ilizem protocolo ISO14443-B devem ser feitas somente através do comando Exchange APDU.

Devido a configuração para utilizar o protocolo ISO14443-A ser bem maior que a configuração para o protocolo ISO14443-B, a alteração do protocolo B para A leva um tempo maior para ser completada.

Protótipo: int SMPRF_ ChangeProtType (char ProtocolType)

char ProtocolType – 0 ISO14443-A Mifare® 1 ISO14443-B ST Outros (reservado)

int Sendo: 0 Sucesso

-17 Protocolo não suportado -2 Erro de comunicação

(15)

3 Exemplos de Aplicações.

A seguir temos alguns exemplos de como carregar e utilizar a SmartPortRF.dll em programas desenvolvidos em Visual C++ e Visual Basic

3.1 Exemplo de carga e chamadas utilizando o Visual C++.

O programa abaixo carrega as funções da dll utilizando o modo de ligação explícita. Este executa então uma chamada à função SMPRF_SelectMifareCard para verificar se algum cartão foi detectado, caso positivo um beep é emitido e o led verde pisca.

#include "stdafx.h" #include "stdio.h" #include "iostream" using namespace std;

int main(int argc, char* argv[]) {//0

unsigned int portNum=0; int iResult=0;

char ReaderVersion[50]; char Tamanho;

char bRepeat='s';

unsigned char SerialNum[8];

/* Definição dos ponteiros de funções para carga da explícita dll */ typedef void (__stdcall *cfunc0)();

typedef int (__stdcall *cfunc1)();

typedef int (__stdcall *cfunc2)(unsigned int,unsigned int); typedef int (__stdcall *cfunc3)( char *, char*);

typedef int (__stdcall *cfunc4)(char); typedef int (__stdcall *cfunc5)(char,char); typedef int (__stdcall *cfunc6)(unsigned char*);

typedef int (__stdcall *cfunc7)(unsigned char,unsigned char, unsigned char*); typedef int (__stdcall *cfunc8)(unsigned char,unsigned char *);

typedef int (__stdcall *cfunc9)(unsigned char,PLONG); typedef int (__stdcall *cfunc10)(unsigned char*);

typedef int (__stdcall *cfunc11)(unsigned char*,unsigned char, unsigned char*,unsigned char*); typedef int (__stdcall *cfunc12)(unsigned int);

typedef int (__stdcall *cfunc13)(long,char*,char);

typedef int (__stdcall *cfunc14)(unsigned long *,unsigned long *);

typedef int (__stdcall *cfunc15)(unsigned char ,unsigned char, unsigned char); cfunc0 Close; cfunc1 CardHalt,ReaderRst; cfunc2 Open; cfunc3 Version; cfunc4 Buzzer,ChangeDetecMode,ChangeProtocol; cfunc5 BlinkLeds,CopyValue; cfunc6 SelectCard; cfunc7 CardLogin,AutoLogin,StoreKey; cfunc8 ReadData,WriteData,WryteMKey; cfunc9 ReadValue,WriteValue,IncValue,DecValue; cfunc10 RequestMFCard; cfunc11 ExChAPDU; cfunc12 ChangeBaudRate; cfunc13 ConvBase; cfunc14 MSB2LSB; cfunc15 LogWithKeyStored;

(16)

cout<<"==============================================="<<endl; cout<<"==============================================="<<endl; cout<<"== SmartPort RF Dll tester ==============="<<endl; cout<<"==============================================="<<endl; cout<<"==============================================="<<endl; /*Carrega a dll */ HMODULE hLib=LoadLibrary("SmartPortRF.DLL"); if(hLib==NULL) {//1

cout << "\nUnable to load library!" << endl; cin>> iResult ;

return 0; }//1

cout << "Library loaded: " << endl; Close=(cfunc0) GetProcAddress(hLib,"SMPRF_ClosePort"); Open=(cfunc2) GetProcAddress(hLib,"SMPRF_OpenPort"); Version=(cfunc3) GetProcAddress(hLib,"SMPRF_GetVersion"); Buzzer=(cfunc4) GetProcAddress(hLib,"SMPRF_SendBeep"); BlinkLeds=(cfunc5) GetProcAddress(hLib,"SMPRF_BlinkLeds"); SelectCard=(cfunc6)GetProcAddress(hLib,"SMPRF_SelectMifareCard"); CardLogin=(cfunc7) GetProcAddress(hLib,"SMPRF_LoginToSector"); ReadData=(cfunc8) GetProcAddress(hLib,"SMPRF_ReadDataBlock"); WriteData=(cfunc8) GetProcAddress(hLib,"SMPRF_WriteDataBlock"); ReadValue=(cfunc9) GetProcAddress(hLib,"SMPRF_ReadValueBlock"); WriteValue=(cfunc9)GetProcAddress(hLib,"SMPRF_WriteValueBlock"); WryteMKey=(cfunc8) GetProcAddress(hLib,"SMPRF_WriteMasterKey"); IncValue=(cfunc9) GetProcAddress(hLib,"SMPRF_IncrementValue"); DecValue=(cfunc9) GetProcAddress(hLib,"SMPRF_DecrementValue"); CopyValue=(cfunc5) GetProcAddress(hLib,"SMPRF_CopyValue"); CardHalt=(cfunc1) GetProcAddress(hLib,"SMPRF_Card_Halt"); RequestMFCard=(cfunc10)GetProcAddress(hLib,"SMPRF_RequestMifareCard"); AutoLogin=(cfunc7) GetProcAddress(hLib,"SMPRF_AutoLogin"); LogWithKeyStored=(cfunc15) GetProcAddress(hLib,"SMPRF_LoginWithKeyStored"); StoreKey=(cfunc7) GetProcAddress(hLib,"SMPRF_StoreKey"); ExChAPDU=(cfunc11) GetProcAddress(hLib,"SMPRF_ExchangeAPDU"); ChangeDetecMode=(cfunc4) GetProcAddress(hLib,"SMPRF_ChangeDetectMode"); ChangeBaudRate=(cfunc12) GetProcAddress(hLib,"SMPRF_ChangeBaudRate"); ReaderRst=(cfunc1)GetProcAddress(hLib,"SMPRF_Reset"); ConvBase=(cfunc13)GetProcAddress(hLib,"SMPRF_ConvBase"); MSB2LSB=(cfunc14)GetProcAddress(hLib,"SMPRF_MSB2LSB"); ChangeProtocol=(cfunc4)GetProcAddress(hLib,"SMPRF_ChangeProtType");

if((CardHalt==NULL) || (ReaderRst==NULL) || (Open==NULL) || (Version==NULL) || (Buzzer==NULL) || (ChangeDetecMode==NULL) || (BlinkLeds==NULL) || (CopyValue==NULL) || (SelectCard==NULL) || (CardLogin==NULL) || (AutoLogin==NULL) || (StoreKey==NULL) || (ReadData==NULL) || (WriteData==NULL) || (WryteMKey==NULL) || (ReadValue==NULL) || (WriteValue==NULL) || (IncValue==NULL) || (DecValue==NULL) || (RequestMFCard==NULL) || (ExChAPDU==NULL) || (ConvBase==NULL) || (ChangeBaudRate==NULL) || (MSB2LSB==NULL) || (Open==NULL) || (LogWithKeyStored==NULL))

{//1

cout << "\nUnable to load all functions." << endl; cin>> iResult ;

FreeLibrary((HMODULE)hLib); return 0 ;

}//1

cout << "Selecione a porta: "<<flush; cin>>portNum;

cout << "Abrindo a porta..."<<portNum<<endl; iResult= Open(portNum,115200);

if (iResult==0) {//1

cout << "Porta Aberta com sucesso." << endl; cout << "Getting Reader Version..."<<endl; iResult=Version(&ReaderVersion[0],&Tamanho); if (iResult==0x00)

{//2

cout<<"\nReader Version is:" <<flush; for (int i= 4; i< (Tamanho);i++)

(17)

{//3 printf("%c",ReaderVersion[i]); }//3 }//2 //=========================================== //=====Loop Start =========================== //=========================================== cin.ignore(100,'\n'); while(bRepeat!='n') {//2

//===Disable Auto Detection iResult=ChangeDetecMode(0x00);

//===== Detecting and getting card serial number iResult=SelectCard(&SerialNum[0]);

if(iResult==0x00 )

{//3

iResult=BlinkLeds(1,0);

iResult=Buzzer(1);

cout<<"\nDetected Card..Serial number is: "<<flush; for( int i=0;i<4;i++)

{ //4 printf("0x%2.2hx ",LOBYTE(SerialNum[i])); }//4 Sleep(200); iResult=BlinkLeds(0,0); cout<<"\nDeseja continuar?...[s],n"<<flush; cin.get(bRepeat); cin.ignore(100,'\n'); }//3 else Sleep(250); }//2 }//1 return 0; }//0

(18)

3.2 Exemplo de carga e chamadas utilizando o Visual Basic 6.

Para utilizar a SmartPortRF.dll no visual Basic. É necessário criar um arquivo de módulo “.bas” contendo as declarações da dll, como mostra o exemplo a seguir.

Arquivo SmartPortRF.bas.

Global Const CHAVE_A = &H60 Global Const CHAVE_B = &H61

'========================================= '========================================= 'STATUS AND ERRORS CODE DEFINITION

'========================================= '========================================= Global Const SUCCESS = &H0

Global Const NOTAG = &H1

Global Const LOGINSUCCESS = &H2 Global Const LOGINFAIL = &H3 Global Const READFAIL = &H4 Global Const WRITEFAIL = &H5

Global Const EEPROMACCESSERR = &H12 Global Const BAUDRATEOUTFRANGE = &H23 Global Const CHKSUMERR = &HF0

Global Const UNKNOWNCMD = &HF1 Global Const TX_ERR = &HFE Global Const TIMEOUT_ERR = &HFF Global Const NOCARD = &HFF

'========================================= '========================================= 'SERIAL BAUD RATE DEFINITION

'======================================== '========================================= Global Const BAUD1200 = 1

Global Const BAUD2400 = 2 Global Const BAUD4800 = 3 Global Const BAUD9600 = 4 Global Const BAUD14400 = 5 Global Const BAUD19200 = 6 Global Const BAUD38400 = 7 Global Const BAUD57600 = 8 Global Const BAUD115200 = 9

'================================================================================ '================================================================================ '==== Declarações para utilizar a bll SmartPortRF

'================================================================================ '================================================================================ Declare Function PortOpen Lib "SmartPortRF" Alias "SMPRF_OpenPort" _

( _

ByVal Numport As Long, _ ByVal BaudRate As Long _ ) As Long

Declare Function PortClose Lib "SmartPortRF" Alias "SMPRF_ClosePort" () As Long Declare Function GetVersion Lib "SmartPortRF" Alias "SMPRF_GetVersion" _ ( _

ByRef Resp As Byte, _ ByRef Tamanho As Byte _ ) As Long

Declare Function SelectCard Lib "SmartPortRF" Alias "SMPRF_SelectMifareCard" _ ( _

ByRef CardSerNum As Byte _ ) As Long

(19)

( _

ByVal Setor As Byte, _ ByVal KeyType As Byte, _ ByRef Key As Byte _ ) As Long

Declare Function ReadData Lib "SmartPortRF" Alias "SMPRF_ReadDataBlock" _ ( _

ByVal Bloco As Byte, _ ByRef ReadData As Byte _ ) As Long

Declare Function WriteData Lib "SmartPortRF" Alias "SMPRF_WriteDataBlock" _ ( _

ByVal Bloco As Byte, _ ByRef WriteData As Byte _ ) As Long

Declare Function ReadValue Lib "SmartPortRF" Alias "SMPRF_ReadValueBlock" _ ( _

ByVal Bloco As Byte, _ ByRef Valor As Long _ ) As Long

Declare Function WriteValue Lib "SmartPortRF" Alias "SMPRF_WriteValueBlock" _ ( _

Declare Function WriteMaterKey Lib "SmartPortRF" Alias "SMPRF_WriteMasterKey" _ ( _

ByVal Bloco As Byte, _ ByRef Key As Byte _ ) As Long

Declare Function IncrementValue Lib "SmartPortRF" Alias "SMPRF_IncrementValue" _ ( _

Declare Function DecrementValue Lib "SmartPortRF" Alias "SMPRF_DecrementValue" _ ( _

Declare Function CopyValue Lib "SmartPortRF" Alias "SMPRF_CopyValue" _ ( _

ByVal Fonte As Byte, _ ByVal Destino As Byte _ ) As Long

Declare Function CardHalt Lib "SmartPortRF" Alias "SMPRF_Card_Halt" _ () As Long

Declare Function RequestCard Lib "SmartPortRF" Alias "SMPRF_RequestMifareCard" _ ( _

ByRef Resp As Byte _ ) As Long

(20)

( _

ByVal Setor As Byte, _ ByVal KeyType As Byte, _ ByVal KeyNum As Byte _ ) As Long

Declare Function StoreKey Lib "SmartPortRF" Alias "SMPRF_StoreKey" _ ( _

ByVal KeyNum As Byte, _ ByVal KeyType As Byte, _ ByRef Key As Byte _ ) As Long

Declare Function ExchangeAPDU Lib "SmartPortRF" Alias "SMPRF_ExchangeAPDU" _ ( _

ByRef APDU As Byte, _ ByVal CmdLen As Byte, _ ByRef RAPDU, _

ByRef RespLen As Byte _ ) As Long

Declare Function ChangeDetectMode Lib "SmartPortRF" Alias "SMPRF_ChangeDetectMode" _

( _

ByVal Mode As Byte _ ) As Long

Declare Function BlinkLeds Lib "SmartPortRF" Alias "SMPRF_BlinkLeds" _ ( _

ByVal Leds As Byte, _ ByVal Intervalo As Byte _ ) As Long

Declare Function SendBeep Lib "SmartPortRF" Alias "SMPRF_SendBeep" _ ( _

ByVal BeepNum As Byte _ ) As Long

Declare Function ChangeBaudRate Lib "SmartPortRF" Alias "SMPRF_ChangeBaudRate" _ ( _

ByVal BaudRate As Byte _ ) As Long

Declare Function ReaderReset Lib "SmartPortRF" Alias "SMPRF_Reset" _ () As Long

Declare Sub MSB2LSB Lib "SmartPortRF" Alias "SMPRF_MSB2LSB" _ ( _

ByRef Origem As Long, _ ByRef Destino As Long _ )

Declare Function ChangeProtocol Lib "SmartPortRF" Alias "SMPRF_ChangeProtType" _ ( _

ByVal Protocol As Byte _ ) As Long

Declare Function Converte Lib "SmartPortRF" Alias "SMPRF_ConvBase" _ ( _

ByVal ValorInicial As Long, _ ByRef ValorFinal As Byte, _ ByVal base As Byte _

(21)

4 Protocolo de Comunicação

Para se comunicar com o leitor sem o uso da SmartPortRF.dll , é necessário utilizar o protocolo de comunicação descrito a seguir. Este protocolo é aplicado em casos que o acesso é feito diretamente pela porta serial, por um PC ou outro microcontrolador.

4.1 Configuração da Comunicação

A comunicação é do tipo orientada à byte. Os bytes recebidos e enviados são em formato hexadecimal. Os parâmetros de comunicação são:

Baud Rate: 1200 a 115200 (default) Dados: 8 bits

Stop bit: 1

Paridade: Sem paridade

Controle de Fluxo: sem controle de fluxo.

4.1.1 Framing de Comunicação

Formato da mensagem:

Comunicações vindas do Host para o Leitor serão daqui a diante referenciadas por HàL.

HàL

Onde:

Endereço: 1 Byte Endereço do Leitor Default 0xBA.

Tamanho: 1 Byte Número de bytes do comando ao checksum (inclusive).

Comando: 1 Byte Comando a ser executado pelo leitor.

Dados: Campo de tamanho variável, dependente do tipo de comando, podendo em alguns casos ser nulo.

Checksum: 1 Byte “XOR” do cabeçalho aos dados

Comunicações vindas do Leitor para o Host serão daqui a diante referenciadas por LàH.

LàH.

Onde:

Endereço: 1 Byte Endereço de reposta do Leitor 0xBD1.

Tamanho: 1 Byte Número de bytes do comando ao checksum (inclusive).

Comando: 1 Byte Comando executado pelo leitor.

Status: 1 Byte Resultado do comando executado

Endereço Tamanho Comando Dados Checksum

(22)

4.2 SET de Comandos e Status

Comando

ByteCode

Select Card 0x01

Login to Sector 0x02

Read Data Block 0x03

Write Data Block 0x04

Read Value Block 0x05

Write Value Block 0x06

Write Key A 0x07

Increment Value 0x08

Decrement Value 0x09

Copy Value 0x0A

Card Halt 0x0B

Request MIFARE Card 0x0D

AutoLogin 0x0E

Login with Key Stored 0x12

Store Key 0x13

Exchange APDU 0x22

Send_Beep 0x40

Change Baud Rate 0x42

Get Version 0x50

Change Card Baud Rate 0x52

Change Detection Mode 0x54

Set_Data_Source* 0x55 Protocol_Change 0x56 Blink_Led 0x60 Get_Reader_Ser_Num 0x61 Set_Network_Addr 0x62 Reset RF Field 0xFF

*Comando somente válido, para leitores operando no modo de emulação

Status

ByteCode

Sucesso 0x00

Cartão não detectado 0xFF

Falha no Login 0x03

Falha na Leitura 0x04

Falha na escrita 0x05

Erro de leitura após escrever 0x07

Erro de acesso a EEPROM 0x12

UART- Baud Rate não suportado 0x23

Card - Baud Rate não suportado 0xCA

Time Out de Operação 0xE5

Protocolo não suportado 0xEF

Erro de Checksum 0xF0

(23)

4.2.1 Select Card

Este comando verifica se há algum cartão no campo de atuação da antena e retorna o número serial caso encontre um cartão.

Comando HàL

Padrão:

Existe uma segunda variação onde é possível enviar o número serial do cartão a ser selecionado.

Desta forma o comando passa a ser:

Variação:

Resposta L à H

Retorno:

Onde:

Status: 0x00 Sucesso

0xFF Cartão não detectado 0xF0 Erro de Checksum

Número Serial:

4 Bytes Número serial do cartão caso a operação tenha sido bem sucedida

Tipo: Tipo do Cartão: 04 Mifare 1K 02 Mifare 4K 44 Mifare UltraLigth 47 Mifare DesFire

4.2.2 Login to Sector

Este comando executa o login de setor num cartão previamente selecionado. Comando HàL

Onde:

Setor: 1 Byte Setor para executar o login

Tipo 1 Byte Tipo de Chave a ser utilizada chave A(0x60) ou chave B(0x61)

Chave 6 Bytes Chave de autenticação.

End. Tamanho 0x01 Checksum

End. Tamanho 0x01 Número Serial (4 bytes) Checksum

End. Tamanho 0x01 Status Número Serial (4 bytes) Tipo Checksum

(24)

Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x03 Falha no Login 0xF0 Erro de Checksum

4.2.3 Read data block

Comando para a leitura de um bloco de 16 bytes, dentro de um setor previamente autenticado.

Comando HàL

Onde:

Bloco: 1 Byte Número do Bloco a ser lido

0x00 – 0x3F para cartões MIFARE 1K 0x00 – 0xFF para cartões MIFARE 4K

Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x04 Falha na Leitura 0xF0 Erro de Checksum

Dados 16 bytes Este bloco de dados somente é retornado se houver sucesso na operação.

4.2.4 Write data block

Comando para a escrever em um bloco de 16 bytes, dentro de um setor previamente autenticado.

Comando HàL

Onde:

Bloco: 1 Byte Número do Bloco a escrever

Dados: 16 Bytes Dado a escrever

End. Tamanho 0x02 Status Checksum

End. Tamanho 0x03 Status Dados Checksum End. Tamanho 0x03 Bloco Checksum

(25)

Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x05 Falha na escrita 0xF0 Erro de Checksum

Dados: 16 Bytes Quando a operação é bem sucedida este bloco retorna o dado escrito

4.2.5 Read Value block

Comando para a leitura de um bloco de valor (4 bytesà Long), dentro de um setor previamente autenticado.

Comando HàL

Onde:

Bloco: 1 Byte Número do Bloco a ser lido

0x00 – 0x3F para cartões MIFARE 1K 0x00 – 0xFF para cartões MIFARE 4K Resposta Là H

Retorno:

Onde:

Status: 0x00 Sucesso 0x04 Falha na Leitura

0x0E O bloco lido não é um bloco de valor 0xF0 Erro de Checksum

Valor: 4 bytes valor retornado se a operação for bem sucedida. Exemplo do formato de valor. Valor =100 à 0x64 0x00 0x00 0x00.

4.2.6 Write Value block

Comando para escrever um bloco de valor (4 bytesà Long), dentro de um setor previamente autenticado.

Comando HàL

End. Tamanho 0x04 Status Dados Checksum

End. Tamanho 0x05 Status Valor Checksum End. Tamanho 0x05 Bloco Checksum

(26)

0x00 – 0xFF para cartões MIFARE 4K

Valor: 4 bytes Valor a escrever.

Exemplo do formato de valor. Valor =100 à 0x64 0x00 0x00 0x00 Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x05 Falha na escrita 0xF0 Erro de Checksum

Valor: 4 bytes Valor escrito se a operação for bem sucedida

4.2.7 Write Master Key (Chave A)

Este comando atualiza a chave A e mantém as regras de acesso e a chave B. Comando HàL

Onde:

Setor: 1 Byte Setor Trailer onde gravar a chave. 0x00 – 0x0F para cartões MIFARE 1K 0x00 – 0x27 para cartões MIFARE 4K

Chave: 6 Bytes Nova chave de autenticação

Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x05 Falha na escrita 0xF0 Erro de Checksum

End. Tamanho 0x06 Status Valor Checksum

End. Tamanho 0x07 Setor Chave Checksum

(27)

4.2.8 Increment Value

Este comando envia ao cartão um valor a ser incrementado no bloco de valor. Após o incremento o resultado da operação e enviado ao Host.

Comando HàL

Onde:

Valor: 4 bytes Valor a incrementar.

Exemplo do formato de valor. Valor =50 à 0x32 0x00 0x00 0x00.

Existe uma segunda variação onde é possível enviar o número do bloco de destino onde o resultado da operação deve ser armazenado. Este bloco deve estar dentro do mesmo setor e seguir as mesmas regras de acesso do bloco fonte.

Nesta variação o bloco fonte permanece inalterado, ou seja com o valor antes da operação.

Variação:

Onde:

Bloco Dest: O número do bloco de destino do resultado da operação. Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x04 Falha na escrita

Valor: 4 bytes Valor após incremento se a operação for bem sucedida

End. Tamanho 0x08 Status Valor Checksum End. Tamanho 0x08 Bloco Valor Checksum

(28)

4.2.9 Decrement Value

Este comando envia ao cartão um valor a ser decrementado à um bloco de valor. Após o decremento o resultado da operação e enviado ao Host.

Comando HàL

Onde:

Valor: 4 bytes Valor a decrementar.

Exemplo do formato de valor. Valor =50 à 0x32 0x00 0x00 0x00.

Existe uma segunda variação onde é possível enviar o número do bloco de destino onde o resultado da operação deve ser armazenado. Este bloco deve estar dentro do mesmo setor e seguir as mesmas regras de acesso do bloco fonte.

Nesta variação o bloco fonte permanece inalterado, ou seja com o valor antes da operação.

Variação:

Onde:

Bloco Dest: O número do bloco de destino do resultado da operação. Resposta Là H

Retorno:

Onde:

Status: 0x00 Sucesso 0x05 Falha na escrita

Valor: 4 bytes Valor após decremento se a operação for bem sucedida

End. Tamanho 0x09 Status Valor Checksum End. Tamanho 0x09 Bloco Valor Checksum

(29)

4.2.10 Copy Value

Este comando copia o valor contido no bloco fonte para o bloco destino. O bloco destino deve estar dentro do mesmo setor e seguir as mesmas regras de acesso do bloco fonte.

Comando HàL

Onde:

Fonte: 1 Byte Número do Bloco a escrever

Destino: 1 Byte Número do Bloco a escrever

0x00 – 0x3F para cartões MIFARE 1K 0x00 – 0xFF para cartões MIFARE 4K Resposta Là H

Retorno:

Onde:

Status: 0x00 Sucesso 0x05 Falha na escrita

Valor: 4 bytes Valor copiado se a operação for bem sucedida

4.2.11 Card Halt.

Este comando coloca o cartão previamente selecionado em estado Halt. Comando HàL Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0xF0 Erro de Checksum 0xFF Cartão não detectado

End. Tamanho 0x0A Status Valor Checksum End. Tamanho 0x0A Fonte Destino Checksum

End. Tamanho 0x0B Status Checksum End. Tamanho 0x0B Checksum

(30)

4.2.12 Request MIFARE Card.

Envia comando de request Requisita ATQA Comando HàL Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0xF0 Erro de Checksum 0xFF Cartão não detectado

ATQA: 2 Bytes Answer to request ISO-1443A

4.2.13 Auto Login.

Este comando executa automaticamente o Select Card e depois executa o login no setor desejado.

Comando HàL

Onde:

Tipo: 1 Byte Tipo de Chave a ser utilizada chave A(0x60) ou chave B(0x61).

Chave: 6 Bytes Chave de autenticação.

Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x03 Falha de Login 0xF0 Erro de Checksum 0xFF Cartão não detectado

End. Tamanho 0x0D Checksum

End. Tamanho 0x0E Status Checksum

End. Tamanho 0x0E Setor Tipo Chave Checksum End. Tamanho 0x0D Status ATQA Checksum

(31)

4.2.14 Login With key stored.

Este comando executa login com uma chave previamente carregada na EEPROM do leitor

Comando HàL

Onde:

Tipo 1 Byte Tipo de Chave a ser utilizada A (0x60) ou chave B(0x61).

Num. Chave: O número da chave armazenada na EEPROM (0 – 31). Resposta Là H Retorno: Onde: Status: 0x00 Sucesso 0x03 Falha de Login 0xF0 Erro de Checksum

4.2.15 Store Key.

Este comando armazena na EEPROM uma chave tipo A, que poderá ser futuramente utilizada em autenticações. Esta chave é armazenada de forma criptografada.

Comando HàL

Onde:

Num. Chave: 1 Byte Numero da Chave a ser armazenada (0 a 31)

Chave: 6 Byte Chave a ser armazenada na EEPROM.

Tipo: 1 Byte Tipo de chave podendo ser tipo A(0x60) ou

End. Tamanho 0x12 Setor Tipo Num. Chave Checksum

(32)

Resposta Là H

Retorno:

Onde:

0x12 Erro de acesso a EEPROM 0xF0 Erro de Checksum

4.2.16 Exchange APDU

Este comando envia um APDU ao cartão e aguarda a resposta. Comando HàL

Onde:

APDU: Comandos APDU

Resposta Là H

Retorno:

Onde:

0xE5 Time Out da Operação (cartão não respondeu) 0xF0 Erro de Checksum

0xFF Cartão não detectado

Resposta: R-APDU

4.2.17 Send_Beep

Este comando faz com que o leitor emita um número x de beeps. Comando HàL

Onde:

Beeps: 1 Byte Número de Beeps a soar 1 a 15 beeps. Resposta Là H

Retorno:

Onde:

0xF0 Erro de Checksum

End. Tamanho 0x22 Status Resposta Checksum End. Tamanho 0x22 APDU Checksum

(33)

4.2.18 Change Baud Rate

Este comando configura a velocidade de comunicação entre o Leitor e o Host. A velocidade de comunicação será gravada na EEPROM e passará ser a velocidade default. Comando HàL Onde: Velocidade: 1 Byte 0x01 1200 bps 0x02 2400 bps 0x03 4800 bps 0x04 9600 bps 0x05 14400 bps 0x06 19200 bps 0x07 38400 bps 0x08 57600 bps 0x09 115200 bps Resposta Là H Retorno: Onde: Status: 0x00 Sucesso

0x23 Valor fora da Faixa. 0xF0 Erro de Checksum

4.2.19 Get Version

Este comando retorna a versão e data do firmware do Leitor Comando HàL

Resposta Là H

Retorno:

O Leitor retorna em ASCII a versão e data do firmware instalado.

End. Tamanho 0x42 Status Checksum End. Tamanho 0x42 Velocidade Checksum

End. Tamanho 0x50 Checksum

(34)

Se status= Sucesso Firmware – Versão / Data:

CIS SmartPort-MF V:1.00.01--16/JAN/06—STD

Nome do Leitor: CIS SmartPort-MF; Versão de Firmware: V: 1.00.01; Data de Release: 16/JAN/06;

Padrão de Saída de Dados: STD/ EMU

4.2.20 Change Card Baud Rate

Este comando altera a velocidade de comunicação entre o Leitor e o cartão. Para funcionar corretamente é necessário que a velocidade enviada pelo comando seja suportada pelo cartão

Este comando somente deve ser utilizado por usuários com conhecimento avançado, pois valores errados podem comprometer o funcionamento do leitor. Após o reset ou desernegização do leitor a velocidade de comunicação volta para o valor default 106kbps

Comando HàL

Onde:

Destino: 2 Bytes Os bytes devem ser sempre iguais 0x00-0x00 106k bps (default) 0x01-0x01 212k bps 0x02-0x02 424K bps 0x03-0x03 848K bps Resposta Là H Retorno:

O Leitor retorna apenas o status.

Onde:

0xCA Card - Baud Rate não suportado 0xF0 Erro de Checksum

End. Tamanho 0x52 Status Checksum End. Tamanho 0x52 Valor Checksum

(35)

4.2.21 Change Detection Mode

Este comando altera o modo como o leitor informa ao Host que um cartão foi detectado.

No modo default todas estas funções estão desabilitadas.

Caso o leitor trabalhe ligado em rede, este comando não deve ser utilizado, uma vez que em rede todos os leitores se comportam como Slaves e

nunca devem iniciar uma transação ou envio de mensagem que não tenha sido previamente requisitada pelo Host.

O modo de detecção será gravado na EEPROM e passará ser o modo default. Comando HàL

Onde:

Mode: 1 Byte Bit 0 Método de detecção do Host Pooling=0 / IRQ=1 (defautl 0)

Bit 1 Reservado

Bit 2 Emite Beep Não 0 / Sim 1 (default – 0) Bit 3 Pisca Led Verde Não 0 / Sim 1 (default –

0)

Bit 4 Protocol Detection MIFARE Não 0 / Sim 1 (Default –0)*.

Bit 5 Protocol Detection ISO144443-B Não 0 / Sim 1 (Default –0)*.

Bit 6 e Bit7

Reservados

* Para melhoria de performance, é recomendado que seja habilitado somente o protocolo utilizado pelo cartão suportado pela aplicação.

Resposta Là H

Retorno:

Onde:

Como exemplo de configuração ao enviar o comando com Mode = 0x3D, toda vez que um cartão for detectado, o leitor enviará ao Host uma mensagem contendo o número serial do cartão, o led verde piscará uma única vez e um beep será emitido.

Após o envio da mensagem de detecção, o leitor sairá do modo de detecção automática. Este modo somente será reativado após o envio de um dos seguintes comandos: CARD HALT (0x0B), RESET RF Field (0xFF), e SELECT CARD (0x01 – neste caso somente quando a resposta for cartão não detectado).

End. Tamanho 0x54 Status Checksum End. Tamanho 0x54 Mode Checksum

(36)

4.2.22 Set Data Source

Este comando somente é válido para leitores que operem no modo EMU e para cartões do tipo MIFARE Standard 1K ou 4K

Este comando configura um setor, o bloco e a senha para acesso dos cartões a serem lidos.

Para que o comando funcione corretamente é necessário que as chaves estejam previamente carregadas no leitor para isso utilize o comando Store

Key.

Desta forma é possível configurar o cartão com os dados que o sistema esteja esperando, dados estes que anteriormente eram enviados por um leitor de códigos de barras ou cartão magnético.

Comando HàL

Onde:

Setor: 1 Byte Número do setor onde o leitor irá executar o login

Bloco: 1 Byte Numero do bloco (deve pertencer ao setor logado) a ser lido.

Num. Chave: 1 Byte Número da chave armazenada na memória do leitor

Para voltar ao modo EMU padrão onde somente é lido o número de serial do cartão

Enviar o comando Set Data Source com todos os parâmetros zerados. Resposta Là H

Retorno:

Onde:

(37)

4.2.23 Protocol Change

Utilize este comando para alternar entre os protocolos ISO14443-A. (MIFARE) e ISO14443-B.

Nota: As comunicações com cartões que utilizem protocolo ISO14443-B devem ser feitas somente através do comando Exchange APDU.

Devido ao número de configurações para utilizar o protocolo ISO14443-A ser bem maior que as configurações para o protocolo ISO14443-B a alteração do tipo protocolo B para protocolo A leva um tempo maior para ser completada. Comando HàL

Onde:

Protocolo: 1 Byte 0x00 ISO14443-A (MIFARE®)

0x01 ISO14443-B

Outros valores Reservados não utilizar. Resposta Là H

Retorno:

Onde:

0xEF Protocolo não suportado 0xF0 Erro de Checksum

4.2.24 Blink Led

Este comando controla os estado dos leds (ligado, desligado, piscando) Comando HàL

Onde:

Leds: 1 Byte Bit 0 Led Verde ON=1 / Off=0 Bit 1 Led Vermelho ON=1 / Off=0 Bit 2 Piscar Alternado Sim=1 / Não =0 2 Bit 3 Reservado

Bit 4 Led Amarelo ON=1 / Off=0

Intervalo: 1 Byte Intervalos e duração da piscada em valores

múltiplos de 10ms. Este valor é

compartilhado pelos Leds Vermelho e Verde3

0 Não Pisca

End. Tamanho 0x60 Leds Intervalo Checksum End. Tamanho 0x56 Status Checksum

(38)

Para apagar todos os leds enviar o comando com todos os parâmetros zerados. O Led amarelo tem prioridade de comando sobre os outros dois Leds, desta forma quando o leitor recebe este comando com o campo Leds bit4=1 a operação será executada somente para o led amarelo

Resposta Là H

Retorno:

Onde:

4.2.25 Get_Reader_Ser_Num

Com este comando é possível obter o número de série do leitor. O número de série é unívoco e composto de 4 bytes hexadecimais.

Desta forma poderemos ter de 00000000h até FFFFFFFFh perfazendo um total de 4.294.967.295 números serias distintos.

Comando HàL

Onde:

Valor: 01 – Numero de Serie Outros Valores -- Reservado Resposta Là H

Retorno:

Onde:

Número de Série: 4 bytes Hexadecimais

4.2.26 Set_Network_Addr

Utilize este comando para configurar o endereço de rede do leitor.

Uma vez configurado o endereço de rede, o leitor passa a responder somente mensagens para o endereço programado.

Após a configuração, o endereço 0xBA será assumido como endereço de BROADCASTING, desta forma o leitor ainda atenderá as mensagens endereçadas com o valor 0xBA mas não enviará mensagens de resposta. Para apagar o endereço de rede e fazer com que o leitor volte ao modo de funcionamento compatível com as versões anteriores configurar o endereço de rede com valor 0x00.

End. Tamanho 0x61 Status Número de Série Checksum End. Tamanho 0x61 Valor Checksum

(39)

Comando HàL

Onde:

Valor: Valor do Endereço de Rede a ser gravado no leitor Resposta Là H

Retorno:

Onde:

Valor: Novo endereço de rede para próximas mensagens NOTA:

Os 3 valores de endereço abaixo são reservados e não devem ser utilizados para enumerar leitores numa rede, são eles:

0x00 à Endereço Inicial para um leitor não configurado. 0xBA à Endereço de Broadcasting

0xBDà Endereço de mensagem de resposta utilizado quando o leitor está operando no modo de compatibilidade com versões anteriores.

4.2.27 Reset Reader

Este comando reseta o leitor.

Utilize este comando nos casos de configurações erradas ou erros repetidos de comunicação entre o leitor e o cartão.

Comando HàL

Resposta Là H

Retorno:

Onde:

End. Tamanho 0xFF Checksum

End. Tamanho 0xFF Status Checksum

End. Tamanho 0x62 Status Valor Checksum End. Tamanho 0x62 Valor Checksum

(40)

5 Especificações

Parâmetro Valor Observações

Alimentação: 5V ± 10% Por fonte externa ou porta PS2 do PC. Opção de 6 a 12 volts sob consulta

Consumo: Típico 98mA Máximo 110mA

Temperatura de

Operação: -20 a 65 ºC

Antena: Blindada -∅5,5cm

Antenas blindadas geram maior direcionalidade, melhor imunidade e menor geração de Interferências. Possibilita ainda que leitores trabalhem próximos e de forma simultânea a uma distancia mínima de 5cm entre eles.

Alcance: Até 5 cm Depende do cartão utilizado

Comunicação: RS-232C

1200 bps a 115200 bps

Default 115200

Para envio de comandos ao leitor

Interfaces de Saída de Dados: RS-232C Sinalização: Sonora: Buzzer

Visual: 1 Led Vermelho 1 Led Verde

Buzzer e Leds controlados pela aplicação

Memória: Suporta até 32 senhas de

acesso Senhas criptografadas

Dimensões: OEM 65 x 86,5 x 16 mm Gabinete 83 x 89 x 28 mm Peso: OEM: 26 g. Com gabinete: 78g

6 Pinagem

A figura abaixo mostra a pinagem do conector RJ10 utilizado nos modelos de placa padrão Pino Sinal 1 Não Conectado 2 S_RTS/CLS** 3 S_CLK**/DATA1*** 4* S_DATA**/DATA0*** 5 Config 6 5Vcc 7 GND 8 RX do Leitor 9 TX do Leitor 10 Não Conectado CN4 1 2 10

(41)

Smart Port RF

Anexo I

(42)

I. Objetivo

Este anexo tem por objetivo esclarecer os detalhes do Leitor SmartPort RF Versão OEM. A versão OEM Standard possui interface serial RS-232C ou TTL.

II. O que há de novo:

A versão OEM possui 3 novas características são elas: § Endereçamento Lógico;

§ Controle de Direção RX-TX; § Modo de Compatibilidade;

§ Mudança no Modo default de Detecção; § 3º. LED amarelo

Estas novas características serão detalhadas nos sub-títulos a seguir.

III. Pinagem:

A figura abaixo mostra a localização do conector CN1 visto pelo lado do Buzzer

.

* Estes pinos são utilizados pelo leitor Smartport RF operando no modo EMU

Pino Sinal 1 S_RTS/CLS 2 S_CLK/DATA1* 3 S_DATA/DATA0* 4* Config* 5 5Vcc 6 GND 7 RX do Leitor 8 TX do Leitor 1 8 CN1

(43)

IV. Multiponto / Ponto a Ponto

O Smartport RF OEM Standard pode operar em dois tipos de rede:

• Multi-Ponto – Vários leitores são conectados em um único ponto de controle (Host).

• Ponto a Ponto – Cada leitor está conectado a apenas um ponto de controle. O Smartport RF OEM Standard oferece suporte e controle lógico destes tipos de redes.

IV.I Endereçamento Lógico

O endereçamento lógico permite que mais de um leitor compartilhe o mesmo meio físico de comunicação, desta forma é possível estabelecer uma rede de leitores, operando no modo Master-Slave sendo o Host (PC ou placa controladora) o Master e todos os leitores Slaves.

Neste modo de funcionamento o Host sempre inicia a comunicação, enviando uma mensagem para um endereço específico, e somente o leitor a quem a mensagem foi endereçada responderá ao Host. Caso não exista nenhum leitor com o endereço igual ao endereço da mensagem, nenhuma resposta será retornada ao Host.

Ainda é possível enviar simultaneamente, mensagens de comando a todos os leitores da rede (BROADCASTING), neste caso todos os leitores executarão o comando, mas não retornarão mensagem de resposta.

No entanto para ligar os leitores em rede, é necessário que as características físicas da rede suportem comunicações do tipo multiponto, como por exemplo, RS -485 e RS -422. Os leitores com firmware versão de V2.00.00 e superiores suportam o modo de endereçamento lógico, possuem controle de fluxo (através do RTS Pino 1 de CN1), podendo ser facilmente adaptados à placas conversores RS-422 e RS-485 com comunicação Half-Duplex a dois fios .

A figura abaixo mostra um exemplo de uma rede de leitores, os conversores RS-485 são

vendidos separadamente.

Importante: Os valores de endereços 0x00, 0xBA e 0xBD são reservados para fins específicos, portanto não devem ser utilizados para endereçar leitores numa rede

IV.II Modo de Compatibilidade

Para manter compatibilidade com as versões anteriores os leitores saem de fábrica configurados com endereço de recepção de mensagem 0xBA e endereço de envio de resposta 0xBD, assim o leitor mantém compatibilidade com as versões anteriores que possuem o formato de mensagem ilustrado abaixo:

Leitor 01 Leitor 02

Leitor 127

(44)

Comando HOSTàLeitor:

Resposta Leitor à HOST:

Note que comandos enviados com o endereço 0xBA (antigo HEADER de comando) recebem respostas com endereço 0xBD (antigo HEADER de Resposta).

Uma vez que o endereço de rede tenha sido configurado através do comando Set_Network_Addr o endereço 0xBA passa a ser o endereço de Broadcasting, e será tratado conforme descrito anteriormente.

Após a configuração do endereç o de rede, as mensagens endereçadas ao leitor, serão executadas e o status de resposta retornado ao Host com o endereço do leitor que as executou.

Para retornar ao modo de operação compatível com as versões anteriores basta enviar o comando Set_Network_Addr com o valor de endereço igual a 0x00.

IV.III Controle de Direção RX-TX

Redes RS-485 a dois fios (Half-duplex) podem requerer controle de direção das mensagens. Firmwares a partir da versão V2.00.00 executam o controle de direção, através do sinal RTS (pino 1 CN1). A tabela abaixo mostra os possíveis estados do Pino RTS e a direção das mensagens:

Direção da Mensagem RTS Descrição

Host à Leitor Baixo (0V) Leitor apto a receber mensagens

Leitor à Host Alto (5V) Leitor respondendo mensagens

Como o leitor opera sempre no modo Slave, ou seja sempre está apto a receber mensagens o valor default para o sinal de RTS é o nível baixo.

Para transmitir uma mensagem de reposta o leitor coloca o sinal de RTS em nível alto e envia a mensagem. O diagrama de sinais é mostrado na figura abaixo:

O tempo após a subida do sinal RTS para o início de envio da mensagem de reposta (Tempo de Guarda) é de aproximadamente 200us.

Após 200us do fim do envio da mensagem de resposta o sinal de RTS volta novamente para o nível baixo.

0XBA Tamanho Comando Dados Checksum

0xBD Tamanho Comando Status Dados Checksum

RTS

MENSAGENS Host à Leitor Leitor à Host