Stránka 1 z 1
Zabezpečenie prenosu dát výpočtom crc.
Napsal: 23 úno 2011, 07:29
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.
Napsal: 23 úno 2011, 14:59
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
Napsal: 23 úno 2011, 17:48
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.
Napsal: 23 úno 2011, 18:16
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.
Napsal: 23 úno 2011, 20:34
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
Napsal: 23 úno 2011, 22:24
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é.
Napsal: 24 úno 2011, 10:13
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'
Napsal: 27 úno 2011, 12:48
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,
sa dá zobraziť niekde v mplabe?
Relatko