ATNEL tech-forum

Re: HTU21D, wyznaczanie CRC.

2016-10-09T22:49:55+01:00

dawid75_75 napisał(a):

Znaczy to, że mamy jak mamy jakiś wielomian n-tego stopnia to binarnie jedynkę mamy tam, gdzie występuje niezerowy współczynnik?
Np.: wielomian X^5+X^3+X^1 binarnie będzie wyglądał tak: 0b101010.
I przy okazji - jak mam rozumieć binarne zapisanie wielomianu? Jak ma się jedno do drugiego?

Dokładnie tak. Ja ten zapis wielomianowy traktuję jako zapis bajtów klucza w sposób skrócony. Bo ile trzeba by napisać gdyby wyraz pierwszy był wyższego rzędu niż. 5?

CRC-32
0x04C11DB7 (tu już zapis hex jest długawy, a wyobraź sobie zapis binarny)
x32 + x26 + x23 + x22 + x16 + x12 + x11 + x10 + x8 + x7 + x5 + x4 + x2 + x1 + 1

Statystyki: Napisane przez Mellanogaster — 9 paź 2016, o 22:49

Re: HTU21D, wyznaczanie CRC.

2016-10-08T20:18:45+01:00

Widzisz, od razu mi jest jaśniej Samą procedurę obliczania CRC już rozumiem.

Mam jeszcze pytanie do wielomianów:

Quote:

Wielomian postaci: X^8+X^5+X^4+X^0 co daje binarnie: 0b100110001

Statystyki: Napisane przez dawid75_75 — 8 paź 2016, o 20:18

Re: HTU21D, wyznaczanie CRC.

2016-10-06T11:08:05+01:00

To może na początek coś na rozruszanie mózgu

Postanowiłem, że napiszę sobie najprostszą funkcję do obliczania CRC dla mojego przypadku.

Założenia były następujące:

- Wielomian postaci: X^8+X^5+X^4+X^0 co daje binarnie: 0b100110001 - długość 9 bitów!!!! - to jest bardzo ważne, 9
- Obrabiane dane mieszczą się w typie uint16_t - jeśli więcej to trzeba zmodyfikować kod.

A działanie przedstawia się następująco:

- do zmiennej roboczej wsuwamy najstarszy bit zmiennej dane
- za pomocą odpowiedniej maski (0b00000001 00000000) sprawdzamy czy przypadkiem już w zmiennej roboczej na pozycji 9 nie pojawila się jedynka
- jeśli nie to wsuwamy następny bit i ponownie sprawdzamy warunek

- pojawiła się w końcu jedynka... więc zmienną roboczą XORujemy wartością naszego wielomianu (0b100110001)

- ... i znowu wsuwamy bit, i znowu sprawdzamy czy na pozycji 9...

jak długo? odpowiedź: tyle ile jest bitów w naszej zmiennej dane plus długość naszego wielomianu (9bitów) minus jeden co daje łącznie 24 przesunięcia
rzecz jasna ostatnie 8 bitów jakie się wsuną to będą same zera.

po tej 24 operacji przesunięcia sprawdzamy co znajduje się aktualnie w naszej zmiennej roboczej .

Powinna to być właśnie suma kontrolna identyczna z tą nadesłaną przez czujnik

podsyłam na szybko prosty kod przedstawiający metodę w akcji .
Był przygotowany w oparciu o zestaw ATB z atmega32A na pokładzie i bibliotekę do obsługi uart z BlueBook'a

[syntax=c]/*
* main.c
*
* AUTHOR: Mellanogaster
*
* www.forum.atnel.pl
*
* 15 wrz 2016
* 17:29:26
*
*/

#include
#include
#include
#include

#include "I2C_TWI/i2c_twi.h"
#include "MK_USART/mkuart.h"

#include "crc8.h"

uint16_t liczba = 0x4E85; // liczba z przykładu z dokumentacji
uint8_t crcWynik;

int main(void){

USART_Init( __UBRR );// inicjalizacja UART

sei();

uart_puts("\r\nLiczba: 0x");
uart_putint(liczba, 16);
uart_puts("\r\nto binarnie: ");

uart_puts("\r\n0b");
uart_putint(liczba, 2);
uart_puts("\r\n");

crcWynik = crc8(liczba);

uart_puts("\r\nObliczone crc: 0x");
uart_putint(crcWynik, 16);

uart_puts("\r\n\r\n");

}[/syntax]

a tutaj jest jest biblioteka do funkcji crc8:
[syntax=c]/************************************************************************/
/* Mellanogaster
*
* www.forum.atnel.pl
*/
/*
*/

#include
#include "MK_USART/mkuart.h"

#include "crc8.h"

uint8_tcrc8 ( uint16_t data_in )
{
uint16_t liczba = 0;
uint8_t bitCnt = 24; // liczba bitów w zmiennej obrabianej + liczba bitow w wielomianie -1 (16 + 9 - 1)
uint16_t reszta = 0;

liczba = data_in;

do {

if((liczba & 0x8000)){
liczba = (liczba<<1);
reszta = (reszta<<1);
reszta |= (0x1);
}
else{
liczba = (liczba<<1);
reszta = (reszta<<1);
}

uart_puts("\r\n");
uart_putint(reszta, 2);

if(reszta & MASKA){
uart_puts("\r\nprzed XOR: ");
uart_putint(reszta, 2);
uart_puts("\r\n");
reszta = reszta ^ CRC8POLY;
uart_putint(CRC8POLY, 2);
uart_puts("\r\n");
uart_puts("po XOR: ");
uart_putint(reszta, 2);

}

bitCnt--;
} while (bitCnt > 0);

return reszta;
}[/syntax]

i plik nagłówkowy
[syntax=c]#ifndef CRC8_H_
#define CRC8_H_

#include

#define MASKA0x100 // 0b100110001
#define CRC8POLY0b100110001 // X^8+X^5+X^4+X^0

uint8_tcrc8 (uint16_t data_in);

#endif[/syntax]

Statystyki: Napisane przez Mellanogaster — 6 paź 2016, o 11:08

Re: HTU21D, wyznaczanie CRC.

2016-10-05T14:47:22+01:00

No pewnie

Statystyki: Napisane przez dawid75_75 — 5 paź 2016, o 14:47

Re: HTU21D, wyznaczanie CRC.

2016-10-04T16:10:39+01:00

Na podstawie dokumentacji napisałem własną obsługę tego czujnika. Właśnie skończyłem CRC. Zainteresowany?

Statystyki: Napisane przez Mellanogaster — 4 paź 2016, o 16:10

HTU21D, wyznaczanie CRC.

2016-08-14T10:10:56+01:00

Szanowni Forumowicze,
Zagłębiając się w temat znalazłem funkcję liczącą CRC w bibliotece na arduino do tego czujnika. Dowiedziałem się też, że jest biblioteka o nazwie crc16.h w katalogu util. Pierwotnie chciałem z niej korzystać, ale wymaga argumentów 8-bitowych, a z tego, co zrozumiałem z datasheet'a czujnika i patrząc na funkcję z biblioteki arduino muszę zlepić ze sobą dane pomiarowe z czujnika, czyli otrzymam 16-bitową liczbę. Postać funckji z crc16.h:
[syntax=c]static __inline__ uint8_t _crc_ibutton_update (uint8_t __crc, uint8_t __data)[/syntax]

Funkcja z biblioteki arduino:
[syntax=c]#define SHIFTED_DIVISOR 0x988000 //This is the 0x0131 polynomial shifted to farthest left of three bytes
uint8_t check_crc(uint16_t message_from_sensor, uint8_t check_value_from_sensor)
{
//Test cases from datasheet:
//message = 0xDC, checkvalue is 0x79
//message = 0x683A, checkvalue is 0x7C
//message = 0x4E85, checkvalue is 0x6B

uint32_t remainder = (uint32_t)message_from_sensor << 8; //Pad with 8 bits because we have to add in the check value
remainder |= check_value_from_sensor; //Add on the check value

uint32_t divsor = (uint32_t)SHIFTED_DIVISOR;

for (int i = 0 ; i < 16 ; i++) //Operate on only 16 positions of max 24. The remaining 8 are our remainder and should be zero when we're done.
{

if( remainder & (uint32_t)1<<(23 - i) ) //Check if there is a one in the left position
remainder ^= divsor;

divsor >>= 1; //Rotate the divsor max 16 times so that we have 8 bits left of a remainder
}

return (uint8_t)remainder;
}[/syntax]

Użycie w programie:
[syntax=c][...]
uint8_t byte0 = twiMaster.readData[0];
uint8_t byte1 = twiMaster.readData[1];
uint8_t byte2 = twiMaster.readData[2];

printf("Kontrola strumienia.\n\n\r");
printf("Wartosci odebranych bajtow: ");
printf(" %d %d\n\r", byte0, byte1);
itoa(byte2, binBuffer, 2);
printf("Checksum: %s\n\r", binBuffer);
uint16_t data = 0;
data = (byte0 << 8) | byte1;
uint8_t crc = check_crc(data, byte2);
printf("CRC: %d\n\r", crc);[...][/syntax]

Starałem się analizować to co piszą w DS do czujnika jednocześnie czytając kod funkcji. I mam problem z tym, że nie do końca rozumiem początek:

Quote:

calculation
To compute an n-bit binary CRC, line the bits representing the input in a row, and position the (n+1)-bit pattern
representing the CRC's divisor (called a "polynomial") underneath the left-hand end of the row.
This is first padded with zeroes corresponding to the bit length n of the CRC.
If the input bit above the leftmost divisor bit is 0, do nothing. If the input bit above the

Podejrzewam, że tu ma uzasadnienie to:
[syntax=c]#define SHIFTED_DIVISOR 0x988000 //This is the 0x0131 polynomial shifted to farthest left of three bytes[/syntax]
W bibliotece arduino jest odnośnik do wiki: http://en.wikipedia.org/wiki/Computatio ... ncy_checks
ale dalej nie wiem skąd SHIFTED_DIVISOR. Widzę, że 0x988 to przesunięcie w prawo o trzy 0x0131 z dopisanymi 12ma zerami z prawej, ale skąd u diabła akurat takie wartości? Ma to związek z wielomianem X^8 + X^5 + X^4 + 1, który jest podany w DS czujnika?

Proszę uprzejmie o wskazówki i pozdrawiam,
Dawid.

Statystyki: Napisane przez dawid75_75 — 14 sie 2016, o 10:10