Struktura protokolu.

Komunikace protokolem EZSP probíhá v datových blocích označovaných jako rámce (frame). Popis těchto rámců najdete v dokumentu ug101-uart-gateway-protocol-reference. I tento dokument jsem si uložil do svého archivu. Každý rámec se skládá z těchto položek:

• Control byte, určuje typ rámce: data, potvrzení příjmu, reset, chybu, RSTACK
• Pole dat, obsahující přenášenou instrukci
• CRC, kontrolní součet, který je dvoubajtový
• Flag byte, vždy 0x7E

Rámec se ale v tomto tvaru přes seriový port nevysílá. Nejprve se provede úprava připravených dat.  V praxi vypadá celý postup odvysílání rámce takto: 

1. Připraví se požadovaná data rámce bez Control Byte, CRC a Flagu
2. Provede se pseudorandomizace dat 
3. Vypočítá se CRC a přidá se na konec dat
4. Provede se proces stuffing
5. Na začátek dat se přidá Control Byte, na konec dat se připojí znak 0x7E
6. Vzniklý binární řetězec se odešle seriovým portem.

 Příjem rámce se provede přesně opačným postupem:

1. Seriovým portem se načítají binární data tak dlouho, dokud nepříjde znak Flag = 0x7E
2. Provede se proces unstuffing
3. Zkontroluje se CRC 
4. Provede se pseudorandomizace dat bez Control Byte, CRC a Flagu.

Takto zpracovaná data jsou přijatým rámcem.

Pseudorandomizace dat

Pseudorandomizaci dat můžeme považovat za jistou formu šifrování. Každý bajt se totiž změní operací XOR na jinou hodnotu. Bajty použité k operaci XOR ale nejsou úplně náhodné, proto pseudorandomizace. První bajt dat se zpracuje vždy s bajtem 0x42. Každý následující bajt pro pseudorandomizaci vzniká přesně definovaným postupem. Tento postup dokumentuje následující kód v pascalu pro data dlouhá 6 bajtů:

// PseudoRandomize
myRnd:=$42;
for I := 1 to 6 do
begin
  localbuff[I]:= localbuff[I] XOR myRnd;
  // vypočítej nový pseudorandom bajt
  if (myRnd MOD 2) = 1 then myRnd:= (myRnd SHR 1) XOR $B8
  else myRnd:= myRnd SHR 1;
end;

Cyklus obvykle začíná pozicí 1, protože před ním je umístěný Control Byte, který se do procesu pseudorandomize nezahrnuje. Takže například řetězec 6 bajtů 010203040506 po aplikaci pseudorandomizace bude obsahovat 4323AB502F13 a po opětovné pseudorandomizaci 010203040506. Pseudorandomizace je symetrický proces. Používá se ten stejný algorytmus pro odeslání i příjem dat. 

Výpočet CRC

Ani výpočet CRC není složitý. Důležité je, že se počítá jako hodnota Word, tedy dva bajty. Výchozí hodnota je vždy 0xFFFF. Vše popisuje následující ukázka kódu v pascalu.

function CRC16_HQX(const Data: array of Byte; Delka: Integer; InitialValue: Word): Word;
var
i: Integer;
CRC: Word;
begin
  CRC := InitialValue;
  for i := 0 to Delka - 1 do
  begin
    CRC := (CRC shl 8) xor CRCTable[((CRC shr 8) xor Ord(Data[i])) and $FF];
  end;
  Result := CRC;
end;

CRCTable má následující hodnotu:

Takže například řetězec 6 bajtů 010203040506 bude mít CRC = 0xD71C.

Stuffing / Unstuffing

Tohle je zajímavý úkon, o kterém jsem dřív nikdy neslyšel. Jde o to, že v protokolu EZSP existují zakázané bajty, které se nesmí vyskytovat ve vysílaném řetězci. Jsou to 0x11, 0x13, 0x18, 0x1A, 0x7E a 0x7D. Pokud je potřeba takovýto bajt odvysílat, nahradí se dvojicí bajtů

• 7D
• zakázaný bajt XOR 0x20

Tím se vysílaný řetězec prodlouží o 1 bajt na každý zakázaný znak. Při příjmu se postupuje tak, že se prochází všechny přijaté bajty. Pokud má některý hodnotu 0x7D, vyloučí se z přijatých dat a s následujícím bajtem se provede operace XOR 0x20. Tím se data vrátí na původní hodnotu.

Pro data dlouhá 9 bajtů by algorytmus stuffing mohl vypadat takto.

// Stuffing
ZeroMemory(@BuffSend,sizeof(BuffSend));
myStf:=0;
for I := 0 to 8 do
begin
  case localbuff[I] of
  $11, $13, $18, $1A, $7E, $7D:
  begin
    BuffSend[myStf + I]:= $7D;
    inc(myStf);
    BuffSend[myStf + I]:= localbuff[I] XOR $20;
  end;
  else BuffSend[myStf + I]:= localbuff[I];
  end;
end;

Opačný algorytmus by mohl vypadat takto.

// Unstuffing
escaped:= False;
myStf:=0;
Count:=0;
ZeroMemory(@localbuff,sizeof(localbuff));
for I := 0 to aLen - 2 do
begin
  myByte:=aData[i];
  if myByte = $7D then escaped:= True
  else
  begin
    if escaped then
    begin
      localbuff[I-myStf]:=aData[I] XOR $20;
      Inc(myStf);
      escaped:=False;
    end
    else localbuff[I-myStf]:=aData[I];
    Inc(Count);
    end;
  end;
ZeroMemory(@aData,sizeof(aData));
for I := 1 to Count-1 do aData[I]:= localbuff[I];

Příklad celého procesu ukážu na jednom přijatém rámci, který obsahuje data 664F21A9062A7D338ED97E

• Nejprve odstraníme Flag byte: 664F21A9062A7D338ED9
• Pak zjistíme, jestli data obsahují bajt 0x7d: 664F21A9062A7D338ED9
• Pokud ano, tento bajt smažeme a s následujícím provedeme operaci XOR 0x20: 664F21A9062A138ED9
• Pak odstraníme úvodní Control Byte a závěrečný CRC: 4F21A9062A13 
• Na tato data uplatníme proces Pseudorandomize: 0D0001520006

Tím získáme datový řetězec rámce. Všechny tři algorytmy je možné testovat v programu ManEZSP bez potřeby připojovat se k seriovému portu. Procedura Calculate XOR Random (Pseudorandomize) v programu nepočítá s prvním bajtem vstupního pole, kterým by měl být Control bajt. Na tom, jaký bajt přidáte na začátek, v tomto případě nezáleží.