Fórum Comunicação ModBus - Leitura de Registrador FieldLog Novus #348640
07/11/2007
0
tenho que fazer uma interface para leitura de uns valores de um registrador FieldLog da empresa Novus, segundo fui informado pelo suporte da empresa o mesmo comunica via protocolo ModBus RTU... depois de pesquisar na internet encontrei um manual com os parametros que devem ser informados na mensagem de envio para leitura de registradores tipo holding, que são:
Endereço do Escravo [7BH], Função do ModBus [03H], Endereço Inicial (+) [00H], Endereço Inicial (-)[6BH], Nro de Registradores (+)[00H], Nro de Registradores (-)[03H], Check Sum Caracter 1 [1], Check Sum Caracter 2 [4]... os valores que estão entre colchetes sao os valores em hexadecimal para leitura do escravao de endereço 124 e dos valores dos registros 40108 a 40110. ai tem certos detalhes como no endereço se for 0007 eu terei q usar 0006, um numero a menos (o por que eu nao sei), acredito que nao se aplica essa ideia para o endereço do escravo já q o endereço de escravo 0 (zero) é usado para mensagens broadcast, os valores deve ser em hexa decimal e converter cada caracter para binário em palavras de 4 digitos, isso pelo que entendi... eu envio tudo isso num mensagem e quem valida se essa mensagem chegou inteira é check sum q é justamente o calculo que nao consegui fazer. a empresa forneceu esse codigo:
Código exemplo do cálculo de CRC:
/*******************************************************************************
* Cálculo do checksum para protocolo ModBus RTU - durante RECEPCAO/TRANSMISSAO
* CRC_HiByte aponta para Tabela CRC +
* CRC_LoByte aponta para Tabela CRC -
* Entrada: buffer a ser analisado e quantidade de caracteres a serem lidos
* Saída: atualiza buffer com o resultado no cálculo de CRC nas posições corretas
*******************************************************************************/
void CRC_RTU_serial(unsigned char *pointer, unsigned char n_caracters)
{
unsigned char cont_carac,carac=0;
CRC_Hi=CRC_Lo=0xFF;
cont_carac=0;
do
{
carac=CRC_Lo^*pointer++;
CRC_Lo=CRC_Hi^CRC_HiByte[carac];
CRC_Hi=CRC_LoByte[carac];
cont_carac++;
} while(cont_carac<n_caracters);
*pointer++=CRC_Lo;
*pointer++=CRC_Hi;
}
se tivesse em pascal seria mais facil de entender.
se alguem souber como passar essa rotina para o delphi e se realmente estou entendendo a ideia, caso contrario me ajudar informando onde estou enganado... e o que falta para comunicação.... obrigado...
vlw...
Endereço do Escravo [7BH], Função do ModBus [03H], Endereço Inicial (+) [00H], Endereço Inicial (-)[6BH], Nro de Registradores (+)[00H], Nro de Registradores (-)[03H], Check Sum Caracter 1 [1], Check Sum Caracter 2 [4]... os valores que estão entre colchetes sao os valores em hexadecimal para leitura do escravao de endereço 124 e dos valores dos registros 40108 a 40110. ai tem certos detalhes como no endereço se for 0007 eu terei q usar 0006, um numero a menos (o por que eu nao sei), acredito que nao se aplica essa ideia para o endereço do escravo já q o endereço de escravo 0 (zero) é usado para mensagens broadcast, os valores deve ser em hexa decimal e converter cada caracter para binário em palavras de 4 digitos, isso pelo que entendi... eu envio tudo isso num mensagem e quem valida se essa mensagem chegou inteira é check sum q é justamente o calculo que nao consegui fazer. a empresa forneceu esse codigo:
Código exemplo do cálculo de CRC:
/*******************************************************************************
* Cálculo do checksum para protocolo ModBus RTU - durante RECEPCAO/TRANSMISSAO
* CRC_HiByte aponta para Tabela CRC +
* CRC_LoByte aponta para Tabela CRC -
* Entrada: buffer a ser analisado e quantidade de caracteres a serem lidos
* Saída: atualiza buffer com o resultado no cálculo de CRC nas posições corretas
*******************************************************************************/
void CRC_RTU_serial(unsigned char *pointer, unsigned char n_caracters)
{
unsigned char cont_carac,carac=0;
CRC_Hi=CRC_Lo=0xFF;
cont_carac=0;
do
{
carac=CRC_Lo^*pointer++;
CRC_Lo=CRC_Hi^CRC_HiByte[carac];
CRC_Hi=CRC_LoByte[carac];
cont_carac++;
} while(cont_carac<n_caracters);
*pointer++=CRC_Lo;
*pointer++=CRC_Hi;
}
se tivesse em pascal seria mais facil de entender.
se alguem souber como passar essa rotina para o delphi e se realmente estou entendendo a ideia, caso contrario me ajudar informando onde estou enganado... e o que falta para comunicação.... obrigado...
vlw...
Dorivansousa
Curtir tópico
+ 0
Responder
Posts
09/11/2007
Dorivansousa
14
3.8.3. Checagem do framing - CRC
No modo RTU, o cálculo de checksum adotado é o CRC, Cyclical Redundandcy Check, que calcula
o conteúdo de toda a mensagem. É gerado um valor de 16 bits sendo que na composição final deste
campo, os 8 bits menos significativos são enviados primeiro e depois os 8 bits mais significativos.
O dispositivo transmissor calcula o valor do CRC e o integra à mensagem, transmitindo-a em
seguida ao dispositivo receptor, que por sua vez, recalcula o CRC de toda a mensagem após a sua total
recepção e o compara ao campo CRC da mensagem recebida, sinalizando erro caso não sejam iguais.
Este método, apesar de levar mais tempo para ser executado em relação ao método LRC, é muito
mais confiável pois, como será visto a seguir, analisa o real conteúdo dos dados, bit a bit, que estão sendo
transferidos na linha de comunicação, fisicamente falando.
O cálculo do CRC é iniciado primeiramente carregando-se um registrador / variável de memória
(referenciado de agora em diante simplesmente como registrador CRC) de 16 bits com valor FFFFH.
Apenas os 8 bits menos significativos deste registrador CRC serão utilizados para o cálculo efetivo do
CRC. Os bits de configuração: start, paridade e stop bits, não são utilizados no cálculo do CRC, apenas os
bits do caracter propriamente dito.
Durante a geração do CRC, cada caracter é submetido a uma lógica XOR (OU exclusivo) com os 8
bits menos significativos do registrador CRC, cujo resultado é retornado a ele mesmo e deslocado (não é
rotacionado) uma posição (1 bit) à direita, em direção ao bit menos significativo, sendo que a posição do
bit mais significativo é preenchida com valor 0 (zero). Após esta operação, o bit menos significativo é
examinado, ocorrendo o seguinte processamento:
1. se o valor deste bit for igual a 0, nada ocorre e a rotina de cálculo do CRC continua normalmente;
Comandos de Pesagem para Modbus RTU / ASCII
15
2. se o valor do bit for igual a 1, o conteúdo de todo o registrador CRC (16 bits) é submetido a uma lógica
XOR com um valor constante A001H e o resultado é retornado ao registrador CRC.
Este processo se repete até que ocorram 8 deslocamentos para cada caracter da mensagem que é
submetido à lógica XOR com o registrador CRC portanto, o processo só terminará após todos os caracteres
da mensagem terem sido submetidos à lógica XOR com o registrador CRC, gerando o valor do CRC que
será colocado no Campo Checksum da mensagem.
Como regra geral, o procedimento para o cálculo do LRC é o seguinte:
1. carrega-se o registrador CRC com o valor FFFFH;
2. submete-se o caracter da mensagem a uma lógica XOR com os 8 bits menos significativos do
registrador CRC, retornando o resultado no registrador CRC;
3. desloca-se o conteúdo do registrador CRC 1 bit par a direita programando seu bit mais significativo
com 0 (zero);
4. examina-se o bit menos significativo do registrador CRC e:
- se bit igual a 0, repete-se o processo a partir do item 3;
- se bit igual a 1, submete-se o registrador CRC a uma lógica XOR com a constante A001H retornando
o resultado no registrador CRC, em seguida, repete-se o processo a partir do item 3;
5. repetem-se os itens 3 e 4 até que tenham ocorrido 8 deslocamentos;
6. repetem-se os itens 2 até 5 para o próximo caracter da mensagem e assim sucessivamente até que todos
os caracteres tenham sido analisados;
7. o valor final do registrador CRC é o valor do Campo Checksum;
8. primeiramente coloca-se o byte menos significativo do registrador CRC na mensagem e depois o mais
significativo.
O processo descrito acima é o chamado cálculo discreto do CRC que, infelizmente, consome muito
tempo para se realizar e começa a ficar crítico à medida que as mensagens passam a ter vários bytes a
serem transmitidos. Para minimizar este problema, foram criadas duas tabelas de 256 bytes cada uma,
contendo todas as possíveis combinações tanto para o byte mais significativo como para o menos
significativo do registrador CRC. O inconveniente deste recurso é que ele requer que o dispositivo possa
dispor de pelo menos 512 bytes da memória de programa para armazenar as duas tabelas porém, o cálculo
será realizado bem mais rápido pois é feito através de indexação dos seus valores. As tabelas e respectivos
valores são mostradas ao final deste item.
Para esta solução o procedimento para o cálculo de CRC é o seguinte:
1. carrega-se ambos registradores CRC+ e CRC– com FFH;
2. as tabelas referenciada como tab CRC + e tab CRC – devem estar previamente programadas com os
respectivos valores das combinações;
3. submete-se o byte da mensagem a uma lógica XOR com o conteúdo do registrador CRC +, retornando
o resultado em um variável de 8 bits referenciada como index;
4. submete-se o valor da tab CRC +, indexada pela variável index, a uma lógica XOR com o registrador
CRC – , retornando o resultado no registrador CRC +;
5. carrega-se o registrador CRC – com o valor da tab CRC – , indexada pela variável index;
6. repete-se os itens 3 à 5 até que todo o conteúdo da mensagem tenha sido analisado;
Comandos de Pesagem para Modbus RTU / ASCII
7. após este processo, os registradores CRC + e CRC – já possuem os respectivos valores a serem
programados no Campo Checksum da mensagem.
Tabela CRC +
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
Tabela CRC –
0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,0x04,
0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,0x08,0xC8,
0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,
0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,0x11,0xD1,0xD0,0x10,
0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,0x3B,0xFB,0x39,0xF9,0xF8,0x38,
0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,
0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,
0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,0xA4,
0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,
0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,0x70,0xB0,
0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,0x99,0x59,0x58,0x98,
0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40,
3.8.3. Checagem do framing - CRC
No modo RTU, o cálculo de checksum adotado é o CRC, Cyclical Redundandcy Check, que calcula
o conteúdo de toda a mensagem. É gerado um valor de 16 bits sendo que na composição final deste
campo, os 8 bits menos significativos são enviados primeiro e depois os 8 bits mais significativos.
O dispositivo transmissor calcula o valor do CRC e o integra à mensagem, transmitindo-a em
seguida ao dispositivo receptor, que por sua vez, recalcula o CRC de toda a mensagem após a sua total
recepção e o compara ao campo CRC da mensagem recebida, sinalizando erro caso não sejam iguais.
Este método, apesar de levar mais tempo para ser executado em relação ao método LRC, é muito
mais confiável pois, como será visto a seguir, analisa o real conteúdo dos dados, bit a bit, que estão sendo
transferidos na linha de comunicação, fisicamente falando.
O cálculo do CRC é iniciado primeiramente carregando-se um registrador / variável de memória
(referenciado de agora em diante simplesmente como registrador CRC) de 16 bits com valor FFFFH.
Apenas os 8 bits menos significativos deste registrador CRC serão utilizados para o cálculo efetivo do
CRC. Os bits de configuração: start, paridade e stop bits, não são utilizados no cálculo do CRC, apenas os
bits do caracter propriamente dito.
Durante a geração do CRC, cada caracter é submetido a uma lógica XOR (OU exclusivo) com os 8
bits menos significativos do registrador CRC, cujo resultado é retornado a ele mesmo e deslocado (não é
rotacionado) uma posição (1 bit) à direita, em direção ao bit menos significativo, sendo que a posição do
bit mais significativo é preenchida com valor 0 (zero). Após esta operação, o bit menos significativo é
examinado, ocorrendo o seguinte processamento:
1. se o valor deste bit for igual a 0, nada ocorre e a rotina de cálculo do CRC continua normalmente;
Comandos de Pesagem para Modbus RTU / ASCII
15
2. se o valor do bit for igual a 1, o conteúdo de todo o registrador CRC (16 bits) é submetido a uma lógica
XOR com um valor constante A001H e o resultado é retornado ao registrador CRC.
Este processo se repete até que ocorram 8 deslocamentos para cada caracter da mensagem que é
submetido à lógica XOR com o registrador CRC portanto, o processo só terminará após todos os caracteres
da mensagem terem sido submetidos à lógica XOR com o registrador CRC, gerando o valor do CRC que
será colocado no Campo Checksum da mensagem.
Como regra geral, o procedimento para o cálculo do LRC é o seguinte:
1. carrega-se o registrador CRC com o valor FFFFH;
2. submete-se o caracter da mensagem a uma lógica XOR com os 8 bits menos significativos do
registrador CRC, retornando o resultado no registrador CRC;
3. desloca-se o conteúdo do registrador CRC 1 bit par a direita programando seu bit mais significativo
com 0 (zero);
4. examina-se o bit menos significativo do registrador CRC e:
- se bit igual a 0, repete-se o processo a partir do item 3;
- se bit igual a 1, submete-se o registrador CRC a uma lógica XOR com a constante A001H retornando
o resultado no registrador CRC, em seguida, repete-se o processo a partir do item 3;
5. repetem-se os itens 3 e 4 até que tenham ocorrido 8 deslocamentos;
6. repetem-se os itens 2 até 5 para o próximo caracter da mensagem e assim sucessivamente até que todos
os caracteres tenham sido analisados;
7. o valor final do registrador CRC é o valor do Campo Checksum;
8. primeiramente coloca-se o byte menos significativo do registrador CRC na mensagem e depois o mais
significativo.
O processo descrito acima é o chamado cálculo discreto do CRC que, infelizmente, consome muito
tempo para se realizar e começa a ficar crítico à medida que as mensagens passam a ter vários bytes a
serem transmitidos. Para minimizar este problema, foram criadas duas tabelas de 256 bytes cada uma,
contendo todas as possíveis combinações tanto para o byte mais significativo como para o menos
significativo do registrador CRC. O inconveniente deste recurso é que ele requer que o dispositivo possa
dispor de pelo menos 512 bytes da memória de programa para armazenar as duas tabelas porém, o cálculo
será realizado bem mais rápido pois é feito através de indexação dos seus valores. As tabelas e respectivos
valores são mostradas ao final deste item.
Para esta solução o procedimento para o cálculo de CRC é o seguinte:
1. carrega-se ambos registradores CRC+ e CRC– com FFH;
2. as tabelas referenciada como tab CRC + e tab CRC – devem estar previamente programadas com os
respectivos valores das combinações;
3. submete-se o byte da mensagem a uma lógica XOR com o conteúdo do registrador CRC +, retornando
o resultado em um variável de 8 bits referenciada como index;
4. submete-se o valor da tab CRC +, indexada pela variável index, a uma lógica XOR com o registrador
CRC – , retornando o resultado no registrador CRC +;
5. carrega-se o registrador CRC – com o valor da tab CRC – , indexada pela variável index;
6. repete-se os itens 3 à 5 até que todo o conteúdo da mensagem tenha sido analisado;
Comandos de Pesagem para Modbus RTU / ASCII
7. após este processo, os registradores CRC + e CRC – já possuem os respectivos valores a serem
programados no Campo Checksum da mensagem.
Tabela CRC +
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
Tabela CRC –
0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,0x04,
0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,0x08,0xC8,
0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,
0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,0x11,0xD1,0xD0,0x10,
0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,0x3B,0xFB,0x39,0xF9,0xF8,0x38,
0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,
0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,
0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,0xA4,
0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,
0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,0x70,0xB0,
0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,0x99,0x59,0x58,0x98,
0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40,
Responder
Gostei + 0
Clique aqui para fazer login e interagir na Comunidade :)