2.3.2.2 – Embaralhamento

Uma parte importante do protocolo de comunicação do Firewire é a que trata do embaralhamento dos bits antes da codificação. Falarei sobre isto primeiro sob um aspecto geral e depois detalharei o processo usado no embaralhamento dos diferentes tipos de dados.

Os bits sofrem um embaralhamento antes da codificação, para evitar a geração de seqüências repetitivas de caracteres de 10 bits idênticos. Casos como este poderiam ocorrer por exemplo quando um mesmo sinal de controle fosse transmitido durante um longo período de tempo ou fossem transmitidas seqüências de dados repetitivas, como vários zeros. O problema que isto acarreta é que estes tipos de seqüência geralmente concentram grandes energias em algumas poucas freqüências, o que pode causar problemas de compatibilidade eletromagnéticas. Fazendo o embaralhamento dos bits antes da codificação, conseguimos espalhar mais uniformemente a energia ao longo da banda de transmissão e com isso minimizar este tipo de problema.

O processo de embaralhamento dos bits pode ser descrito com auxílio do esquema abaixo (Figura 4):

Figura 4 – Embaralhador de bits

Este processo funciona da seguinte forma: os bits x0, x1, ..., x10 são as últimas 11 saídas do embaralhador, sendo x0 a mais recente e x10 a mais antiga. Da mesma forma, k, k +1, ..., k +7 são as últimas 8 saídas do embaralhador, sendo k + 7 a mais recente e k a mais antiga.

Como pode ser visto pelo esquemático, a saída do embaralhador é dada pela função:

Scr(k) = Scr(k-9) XOR Scr(k-11).

À medida que novas saídas vão sendo geradas, as saídas anteriores vão sendo shiftadas, de forma que os bits x contenham as 11 últimas saídas do embaralhador e os bits k contenham as últimas 8 saídas do mesmo. O registrador de saída do embaralhador fornece sempre os bits k, ou seja, os 8 bits gerados mais recentemente.

2.3.2.2.1 – Embaralhamento de dados

Durante a transmissão dos pacotes, o embaralhamento dos dados é feito de acordo com a saída do embaralhador, sendo que este gera 8 bits para cada byte a ser transmitido. A regra segundo a qual os bytes de dados serão embaralhados é a seguinte:

[A',B',C',D',E',F',G',H'] = [A,B,C,D,E,F,G,H] XOR [Scr(k:k+7)]

onde A',B', ..., H' são os bits após o embaralhamento

A,B, ..., H são os bits antes do embaralhamento

Scr(k:k+7) são os últimos 8 bits gerados pelo embaralhador

2.3.2.2.2 – Embaralhamento de símbolos de requisição

Os símbolos de requisição são inicialmente embaralhados da mesma forma que os de dados. Entretanto, após o embaralhamento os bits F' e G' são setados em 0. Isto é feito para garantir que um único erro no caracter de requisição sempre possa ser detectado pelo receptor. Desta forma, a regra segundo a qual os bits serão embaralhados é a seguinte:

[A',B',C',D',E',F',G',H'] = ([A,B,C,D,E,F,G,H] XOR [Scr(k:k+7)]) AND (11111001)

2.3.2.2.3 – Embaralhamento de símbolos de controle

Como os símbolos de controle são formados por 4 bits, em vez de 8, a função de embaralhamento é um pouco diferente das 2 anteriores. O XOR dos 4 bits do símbolo de controle é feito com bits alternados da saída do embaralhador. A regra de embaralhamento é a seguinte:

[P',Q',R',S'] = [P,Q,R,S] XOR [Scr(k), Scr(k+2), Scr(k+4), Scr(k+6)]