Zabezpečenie prenosu dát výpočtom crc.

Diskuze a poradna o programátorech a programování různých obvodů

Moderátor: Moderátoři

Odpovědět
Zpráva
Autor
Uživatelský avatar
relatko
Příspěvky: 85
Registrován: 08 úno 2009, 00:00

Zabezpečenie prenosu dát výpočtom crc.

#1 Příspěvek od relatko »

Zdravím.
Prenášam dáta ,konkrétne reťazec o dĺžke 20 znakov,z jedného na druhé MCU PIC 16F628A.
Na prenos používam bezdrôtové moduly a chcem pravdivosť priatých dát zabezpečiť kontrolným CRC súčtom.
Niečo hotové som našiel na:

http://www.microchipc.com/sourcecode/#crc

Kód: Vybrat vše

Excellent CRC code. 

// Update the CRC for transmitted and received data using
// the CCITT 16bit algorithm (X^16 + X^12 + X^5 + 1).
unsigned char ser_data;
static unsigned int crc;
crc = (unsigned char)(crc >> 8) | (crc << 8);
crc ^= ser_data;
crc ^= (unsigned char)(crc & 0xff) >> 4;
crc ^= (crc << 8) << 4;
crc ^= ((crc & 0xff) << 4) << 1;

Neviem však ako túto funkciu použiť na výpočet CRC.
Viete mi prosím poradiť?
Niečo som o tejto problematike čítal,ale zatiaľ som vedľa.
Relatko.
Uživatelský avatar
mtajovsky
Příspěvky: 3728
Registrován: 19 zář 2007, 00:00
Bydliště: Praha

#2 Příspěvek od mtajovsky »

To je úsek kódu pro update CRC. Na vstup přichází sériově data - do unsigned char ser_data a po každém byte se provede update CRC. Na začátku musíte nastavit v unsigned int crc nějakou počáteční hodnotu. Kód bych asi zabalil do funkce nazvané update_crc:

Kód: Vybrat vše

unsigned int crc;

void update_crc(unsigned char ser_data)
{
    crc = (unsigned char)(crc >> 8) | (crc << 8);
    crc ^= ser_data;
    crc ^= (unsigned char)(crc & 0xff) >> 4;
    crc ^= (crc << 8) << 4;
    crc ^= ((crc & 0xff) << 4) << 1;
}


Nejprve nastavit do crc počáteční hodnotu a pak funkci update volat na každý byte ze stringu, ke kterému se CRC počítá.

Nebo to můžete jdnoduššeji počítat přes tabulku. Kód a použití zde:
http://automationwiki.com/index.php?title=CRC-16-CCITT
Uživatelský avatar
ZdenekHQ
Významný člen
Příspěvky: 25519
Registrován: 21 črc 2006, 00:00
Bydliště: skoro Brno
Kontaktovat uživatele:

#3 Příspěvek od ZdenekHQ »

Jen dodatek, že ten generující polynom by měl odpovídat délce dat, jinak se může stát, že pro různá data je stejné crc. Je to sice náhoda, ale mě se to už stalo.
Pro moje oslovení klidně použijte jméno Zdeněk
Správně navržené zapojení je jako recept na dobré jídlo.
Můžete vynechat půlku ingrediencí, nebo přidat jiné,
ale jste si jistí, že vám to bude chutnat[?
]
Uživatelský avatar
mtajovsky
Příspěvky: 3728
Registrován: 19 zář 2007, 00:00
Bydliště: Praha

#4 Příspěvek od mtajovsky »

Že pro různá data vyjde stejné CRC je pravděpdobnost 1/2^16. CRC 16 má jen 2^16 možných kombinací, a tak, jestliže máme například řetězec dlouhý 128 byte, tak ze všech možných řetězců, kterých je 2^1024 bude mít 2^1008 řetězců stejné CRC. Jinými slovy, vezmeme-li nějaký řetězec a k němu budeme náhodně zkoušet jiné řetězce, tak jednou za 2^16 pokusů CRC neodhalí rozdíl. Zdá se to jako naprosto nespolehlivé, ale chyby se v praxi projevují většinou tak, že je CRC odhalí.

Dnes se v komunikacích používá CRC 32, které má 2^16 krát větší spolehlivost detekce chyby.
Uživatelský avatar
relatko
Příspěvky: 85
Registrován: 08 úno 2009, 00:00

#5 Příspěvek od relatko »

Niečo som o tejto problematike čítal,ale zatiaľ som vedľa.

Vďaka za snahu pomôcť.Poprosím vysvetliť trošku obšírnejšie čo treba urobiť z jednotlivými byte resp. s celím reťazcom na strane "odosielateľa a čo na strane príjemcu.Myslím tým MCU.
Ten kód kde to používa tabuľku nemusí byť zlý,ale spapá mi to veľa pamäte a tou 16-kové pická neoplývajú.
Relatko
Uživatelský avatar
mtajovsky
Příspěvky: 3728
Registrován: 19 zář 2007, 00:00
Bydliště: Praha

#6 Příspěvek od mtajovsky »

Tak předpokládejme, že je přijat textový řetězec do přijímacího bufferu char buff[] jako C řetězec, tedy ukončený '\x00'.

Kód: Vybrat vše


// -------------------- tohle do headeru ---------------

...
#define SEED 0x0f1d                 // pocatecni nstaveni

static unsigned int get_crc(const unsigned char *buff);
static unsigned int update_crc(unsigned char ser_data, unsigned int crc);
....

// ------------------ tohle do kodu ---------------------

unsigned char uc_buff[1024];       // je dostatecne dlouhy pro prijata data
unsigned int ui_crc;               // vysledne CRC
...

// --------------- nejaky hlavni beh ----------------

...
     ui_crc = get_crc(uc_buff);

....


// -------------- rutiny -------------------------------

unsigned int get_crc(const unsigned char *buff)
{
unsigned int ui_crc = SEED;         // vysledne CRC
char *pc_ptr = buff;                // pointer do bufferu

    while(*ptr)
    {
        ui_crc = update_crc(*ptr++, ui_crc);
    };
    return ui_crc;
}


unsigned int update_crc(unsigned char ser_data, unsigned int crc)
{
    crc = (unsigned char)(crc >> 8) | (crc << 8);
    crc ^= ser_data;
    crc ^= (unsigned char)(crc & 0xff) >> 4;
    crc ^= (crc << 8) << 4;
    crc ^= ((crc & 0xff) << 4) << 1;
    return crc;
}


Nějak takhle, trochu jsem update_crc() upravil, abychom se obešli bez globálu. POZOR - píšu to z ruky, neprošlo to překladem ani laděním. To už je na vás.

Na straně odesílatele spočítáte z dat připravených na odeslání CRC, to připojíte za konec dat a vše odešlete. Na straně příjemce spočítáte CRC úplně stejně jako na vysílači a pak je srovnáte s CRC, které bylo přijato. Když se shodne, data nějak akceptujete, když ne, tak je odmítnete. To už je záležitost přenosového protokolu.

Pokud byste přijímal i data, která mohou obsahovat nulové byty, musíte si do výpočtu CRC vnést i údaj o délce dat. Tento údaj stejně musíte přenášet mezi vysílačem a přijímačem, abyste na přijímači věděl, že je přijata celá dávka dat. A vůbec, daleko důležitější než výpočet CRC je stanovit si formát přenášených dat a způsob jejich potvrzování, včetně time-outů, rozeznání zdvojených dat a podobně. Ono to není zas tak jednoduché, pokud to má být robustní a spolehlivé.
Uživatelský avatar
AB1
Příspěvky: 312
Registrován: 23 lis 2009, 00:00

#7 Příspěvek od AB1 »

Pokud nejde o život, tak by možná stačil méně dokonalý
ale jednodušší způsob kontroly, kde se jenom xorují všechny bajty.

Kód: Vybrat vše

char string1[] = "ABCDEFGHIJK"; 
uint8_t k_s;

//-----------------------------------------------------------------------------

uint8_t k_soucet(char* c)
{
char    s = 0;
uint8_t temp = 0;

   s = c[temp];

   while(1)
   {
      temp++;
      if(!c[temp]) break; //konec řetězce
      s ^= c[temp];
   }
   return (uint8_t)s;
}

//-----------------------------------------------------------------------------

int main(void)
{
 
k_s = k_soucet(string1);  // k_soucet = 'A'xor'B'xor'C' ... xor'K'

Uživatelský avatar
relatko
Příspěvky: 85
Registrován: 08 úno 2009, 00:00

#8 Příspěvek od relatko »

Vďaka za pomoc páni.
Nateraz to cvične vyzerá takto:

Kód: Vybrat vše

#include <pic.h>
#include <stdio.h>
#include "delay.h"
#include "serial.h"

#define SEED 0x0f1d                 // pocatecni nstaveni
#define   max_dat 8

unsigned int   p_1;
unsigned int   p_2;
unsigned char   p_3;
unsigned char   p_4;

unsigned char uc_buff[10];
unsigned int ui_crc;               // vysledne CRC
unsigned int crc;

unsigned int i_nt(unsigned char h,unsigned char l)
   {
      unsigned int ret;
      ret   =   l;                           
      ret   += (h << 8);
      return ret;
   }

unsigned char hi(unsigned int x)
   {
      unsigned char y;
      y=x>>8;
      return y;
   }
unsigned char low(unsigned int x)
   {
      unsigned char y;
      y=x&0x00FF;
      return y;
   }

unsigned int update_crc(unsigned char ser_data, unsigned int crc)
{
    crc = (unsigned char)(crc >> 8) | (crc << 8);
    crc ^= ser_data;
    crc ^= (unsigned char)(crc & 0xff) >> 4;
    crc ^= (crc << 8) << 4;
    crc ^= ((crc & 0xff) << 4) << 1;
    return crc;
}



unsigned int get_crc(const unsigned char *buff)
{
unsigned int ui_crc = SEED;         // vysledne CRC
char *ptr = buff;                // pointer do bufferu
unsigned char x;

    for(x=0;x<max_dat;x++)
    {
        ui_crc = update_crc(*ptr++, ui_crc);
    };
    return ui_crc;
}



void main(void)
{
serial_setup();
p_1=34570;   //premenné z posiel.dátami
p_2=3570;
p_3=70;
p_4=3;

uc_buff[0]=hi(p_1);   //plnenie reťazca
uc_buff[1]=low(p_1);
uc_buff[2]=hi(p_2);
uc_buff[3]=low(p_2);
uc_buff[4]=p_3;
uc_buff[5]=p_4;
uc_buff[6]=0;
uc_buff[7]=0;
ui_crc = get_crc(uc_buff); //výpočet crc
uc_buff[8]=hi(ui_crc);      //vloženie crc do reťazca
uc_buff[9]=low(ui_crc);
//-----------prímacia časť---------------
crc=i_nt(uc_buff[8],uc_buff[9]);// crc z priateho reťazca
uc_buff[2]=9;   // "cvičná" chyba
ui_crc = get_crc(uc_buff);   //výpočet crc
if(crc==ui_crc)            //porovnanie
printf("Dáta sú O.K.");
else
printf("Chyba CRC!");
while(1);
}


A opýtam sa,

Kód: Vybrat vše

printf("napr.Dáta sú O.K."); 

sa dá zobraziť niekde v mplabe?
Relatko
Odpovědět

Zpět na „Programování PIC, ATMEL, EEPROM a dalších obvodů“