Librerie per il calcolo del CRC16 e CRC32

… i due moduli sono in uno zip allegato al primo post di questo thread :wink:

Guglielmo

ok, trovata.
Ho copiato la cartella in arduino/libraries ma quando vado a compilare l’esempio mi da tanti warning? Dove sbaglio?

Se ben ricordo NON avevo strutturato la cosa come una vera libreria, ma come due moduli C separati dei quali includevi solo quello che ti serviva [u]direttamente nel tuo progetto/u ;)

Guglielmo

Ok, quindi dovrei utilizzere o quello a 16crc o 32crc? Cioè dato questo sketch:

#include "crc16.h"
#include "crc32.h"

unsigned int myCrc16;
unsigned long myCrc32;

void setup() {

   delay(3000);
   
   Serial.begin(9600);
   
   myCrc16 = calc_crc16("123456789", 9);
   myCrc32 = calc_crc32("123456789", 9);
   
   #ifdef __SAM3X8E__
      Serial.println("Calculate CRC on string 123456789");
      Serial.print("CRC16 = 0x");
      Serial.println(myCrc16, HEX);
      Serial.print("CRC32 = 0x");
      Serial.println(myCrc32, HEX);
   #else
      Serial.println(F("Calculate CRC on string 123456789"));
      Serial.print(F("CRC16 = 0x"));
      Serial.println(myCrc16, HEX);
      Serial.print(F("CRC32 = 0x"));
      Serial.println(myCrc32, HEX);
   #endif
}

void loop() {

}

Cosa devo cancellare?

Grazie

... devi usare ... quello che ti serve nella TUA applicazione ... XD

Quindi includi solo il .h del crc che vuoi calcolare (o crc16.h per calcolare il crc16 oppure crc32.h se invece vuoi calcolare il crc32) ed, ovviamente, solo le variabili che ti servono ;)

Guglielmo

P.S. : Il codice [u]DEVE SEMPRE[/u] essere racchiuso negli appositi tag "code" e "/code" ... te li mette automaticamente con il bottoncino # che trovi in alto quando scrivi il messaggio. Grazie.

A chi mai servisse, vi allego anche una semplicissima routine che calcola il CRC-8 usando le formule di Dallas/Maxim.

//CRC-8 - algoritmo basato sulle formule di CRC-8 di Dallas/Maxim 
byte CRC8(const byte *data) {
    byte crc = 0x00;

    while (*data) {
        byte extract = *data++;
        for (byte tempI = 8; tempI; tempI--) {
            byte sum = (crc ^ extract) & 0x01;
            crc >>= 1;
            if (sum) {
                crc ^= 0x8C;
            }
            extract >>= 1;
        }
    }
    return crc;
}

Per usarlo basta passare un array di byte e si ha indietro il CRC8. Esempio:

byte vettore[5] = {2, 3, 56, 10, 1};
....
byte risultato = CRC8(vettore);

E' comodo nella trasmissione di piccoli pacchetti dati, giusto come somma di controllo. Se serve maggior sicurezza, usate CRC16 o CRC32.

Bella Leo ... la metto assieme alle altre due ... cosÌ si ha l'imbarazzo della scelta XD XD XD

Guglielmo

P.S. : Sai che non mi è chiaro da dove pesca la lunghezza del vettore che gli passi ... riceve solo un pointer ... come fa a sapere quanti bytes contiene ??? O deve terminare con un byte a 0x00 ???

Dovrebbe funzionare per il fatto che byte in Arduino è un alias di unsigned char. In pratica un array di byte altro non è che un array di unsigned char. Il compilatore dovrebbe mettere il valore \0 alla fine come nel caso dei *char.

Non ho disassemblato il binario però, quindi congetturo.

... ok ... quindi, per stare tranquilli al 100%, ho si inserisce a manina un ultimo valore 0x00 alla fine o si modifica la routine per accettare un parametro in più ... il numero di caratteri (così inoltre diventa congrua con le altre due) ... ]:D ]:D ]:D ]:D

Guglielmo

Mi spieghi questo :sweat_smile:

crc >>= 1;

EDIT ci sono arrivato

crc = crc >> 1;

erpomata: ma per la lunghezza non si potrebbe usare la funzione "sizeof"?

NO! sizeof ritorna la lunghezza dell'array solo se usato sull'array originale, qualsiasi suo altro riferimento (aka puntatore) ritorna la grandezza in byte del PUNTATORE, ovvero 2 byte (da cui ne deriva che al massimo possiamo usare una ram con 65536 byte... poi in realtà grazie ad indirizzo di sfasamento e altri trucchetti puoi incrementare questo valore, ma sto divagando)

gpb01: ... ok ... quindi, per stare tranquilli al 100%, ho si inserisce a manina un ultimo valore 0x00 alla fine o si modifica la routine per accettare un parametro in più ... il numero di caratteri (così inoltre diventa congrua con le altre due) ... ]:D ]:D ]:D ]:D

Guglielmo

La precedente versione di quella routine funzionava proprio così, ossia passando 2 parametri: il vettore e la sua lunghezza. Però giorni fa mi era venuta in mente questa cosa del byte/unsigned char, l'ho voluta provare e pare che funzioni alla perfezione ;)

Sono stato una buona mezz'ora a studiare il disassemblato della funzione. A me pare che sui vettori con dimensione fissa non ci siano problemi perché nel codice il compilatore prima di chiamare la funzione carica l'indirizzo di fine del vettore e nella routine di calcolo del CRC semplicemente confronta il valore corrente del puntatore con la fine precedentemente memorizzata per cui quando arriva in fondo al vettore, lui esce.

leo72:

gpb01: ... ok ... quindi, per stare tranquilli al 100%, ho si inserisce a manina un ultimo valore 0x00 alla fine o si modifica la routine per accettare un parametro in più ... il numero di caratteri (così inoltre diventa congrua con le altre due) ... ]:D ]:D ]:D ]:D

Guglielmo

La precedente versione di quella routine funzionava proprio così, ossia passando 2 parametri: il vettore e la sua lunghezza. Però giorni fa mi era venuta in mente questa cosa del byte/unsigned char, l'ho voluta provare e pare che funzioni alla perfezione ;)

non può funzinare alla perfezione: se io ho un array di byte in cui chessò, ho inviato il gezzo dell'intero 126, avrò inviato 2 byte: 0x00 0x7E però con questo "trucco" il valore 0x7E NON verrà mai controllato. In pratica state dando per scontato che il valore 0x00 NON sia mai contenuto nell'array di byte, cosa che non è assolutamente vera.

Un trucco che si può usare è usare 2 0x00 di fila, e se la stringa di byte contiene due 0x00 di fila nel suo contenuto allora dividerli con un valore noto; in pratica come fa il C con i caratteri di escape. (ha un nome questo sistema, si usa per le comunicazioni, ma non ricordo)

A me pare che sui vettori con dimensione fissa

se ti riferisci a me, sappi che la funzione prende un PUNTATORE all'array di dimensione fissa. quindi un test veritiero deve tenerne conto.

In oltre, lato ricezione, spesso si usa un array a dimensione fissa bello grosso, e lo si riempie finchè ci sono dati; con il sistema dimensione dell'array automatico con sizeof, sei costretto a ridimensionare l'array (o usare un array mallocato sul momento), antrambi i sistemi giocano col l'allocazioe dinamica, che come disse anche astro più volte, è spesso pura follia su un micro come gli atmega.

Non mi riferivo a nessuno. ;) Comunque disassemblando il codice la prima analisi, cioè quella del carattere \0 finale, è errata. Come detto, il compilatore carica l'indirizzo della cella finale e con un semplice confronto controlla quando è arrivato ad essa.

Quindi l'array potrebbe contenere tutti 0x00 ma verrebbe elaborato ugualmente?

lesto: ... non può funzinare alla perfezione: se io ho un array di byte in cui chessò, ho inviato il gezzo dell'intero 126, avrò inviato 2 byte: 0x00 0x7E però con questo "trucco" il valore 0x7E NON verrà mai controllato. In pratica state dando per scontato che il valore 0x00 NON sia mai contenuto nell'array di byte, cosa che non è assolutamente vera. ...

Concordo al 100% ... ... se si deve fare una routine la si deve fare indipendente dal blocco di bytes che deve elaborare e l'unico modo è ... puntatore al blocco, lunghezza del blocco ]:D ]:D ]:D

Guglielmo

leo72: Non mi riferivo a nessuno. ;) Comunque disassemblando il codice la prima analisi, cioè quella del carattere \0 finale, è errata. Come detto, il compilatore carica l'indirizzo della cella finale e con un semplice confronto controlla quando è arrivato ad essa.

Cioè tu vuoi dire che

while (*data) {

}

... viene compilato tramutandolo in un controllo sul fatto che si sia o meno all'interno del blocco puntato ??? E se il pointer che io passo è di una struttura ? O di un elemento di una union ? ... mi sembra azzardato ... :roll_eyes:

Guglielmo

uhmm forse possibile, però a me sembra più voler dire "il valore attualmente puntato da data" (e quindi 0x00 ci frega), se il compilatore fa qualcosa è davvero "sporco", imho

però

while (*data) {
        byte extract = *data++;

a me SEMBRA errato, come sarabbe tradotto?

byte extract = *(data++);

non legge il primo byte e va in overflow di 1

byte extract = (*data)++;

prende il valore puntato e gli somma 1 (e in teoria va in loop infinito)

questa è la versione originale, con la lunghezza:

//CRC-8 - algoritmo basato sulle formule di CRC-8 di Dallas/Maxim 
byte CRC8(const byte *data, byte len) {
    byte crc = 0x00;

    while (len--) {
        byte extract = *data++;
        for (byte tempI = 8; tempI; tempI--) {
            byte sum = (crc ^ extract) & 0x01;
            crc >>= 1;
            if (sum) {
                crc ^= 0x8C;
            }
            extract >>= 1;
        }
    }
    return crc;
}

Se provate con diversi vettori, anche che contengono 0 nei loro elementi, avrete gli stessi risultati fra questa e quella che non vuole la lunghezza dell'array. Poi se trovate un errore a me fa piacere: 1) imparo e la prox volta non o commetto 2) sistemiamo insieme questa funzione Entrambe sono nello spirito dell'open source, non prendo queste critiche male, anzi ;)