Décodage de trames avec des tableaux et opérateurs bit-à-bit

float getTemperature(uint8_t * frame, char * unit) {
    char units[] = {'?', 'C', 'F', 'K'};

    // On extrait la valeur de la t° de la tramme
    float temp = ((frame[ 1 ] << 8) | frame[ 2 ]) / 100.0;

    // SI le bit 7 est à 1 ALORS
    if( (frame[ 3 ] & (1<<7)) != 0) {
        // Inverser le signe de la t° pour obtenir une t° négative
        temp = -temp;
    }
    // FINSI

    // Décoder l'unité de t° (correspondance directe entre le codage de l'unité
    // et le rang de sa valeur dans le tableau `units`).
    int idxUnits = frame[ 3 ] & 0x03;
    *unit = units[  idxUnits ];

    return temp;
}

#include <stdio.h>
#include <math.h> // pow(), NAN
#include <stdint.h> // uint8_t...
#include <stdbool.h> // bool

//CRC
#define POLYNOMIAL 0x131 //P(x)=x^8+x^5+x^4+1 = 100110001

float getSHT20Value(uint8_t * frame) {
    float result;

    // Calculer checksum
    uint8_t crc = 0;
    uint8_t byteCtr;
    for (byteCtr = 0; byteCtr < 2; ++byteCtr) {
        crc ^= (frame[ byteCtr ]);
        for (uint8_t bit = 8; bit > 0; --bit) {
            if (crc & 0x80) {
                crc = (crc << 1) ^ POLYNOMIAL;
            } else {
                crc = (crc << 1);
            }
        }
    }
    // SI erreur de checksum ALORS
    if (crc != frame[ 2 ]) {
        // Résultat fonction = NaN
        result = NAN;
    // SINON
    } else {
       // Décoder trame :
       // 1/ Détecter si trame de T°C ou de RH%
       bool isTemperature;
       if ((frame[ 1 ] & 0x02) != 0) { // bit1 est à 1
          isTemperature = false;
       } else {
          isTemperature = true;
       }

       // 2/ Masquer les 2 bits de poids faible pour obtenir valeur "brute"
       uint16_t rawValue = (frame[ 0 ] << 8) | (frame[ 1 ] & 0xFC);
       //   1111 1100
       // & xxxx xxxx
       // -----------
       //   xxxx xx00


       // 3/ Appliquer la formule appropriée
       // SI trame de T°C ALORS
       if (isTemperature == true) {
          // appliquer T = -46.85 + 175.72 . Valeur brute /  2^16
          result = -46.85 + 175.72 * (rawValue / pow(2, 16));
       } else {
       // SINON
          // appliquer RH = -6 + 125 . Valeur brute / 2^16
          result = -6 + 125 * (rawValue / 65536.0);
       }
    }

   // Renvoyer résultat
   return result;
}

int main()
{
    // trame codant une humidité de 42.5% avec un checksum correct
    uint8_t frameHChksOK[] = {0x63, 0x52, 0x64};

    // trame codant une humidité de 42.5% avec un checksum incorrect
    uint8_t frameHChksNOK[] = {0x63, 0x52, 0xaa};

    // trame codant une température de 19.6°C avec un chesksum correct
    uint8_t frameTChksOK[] = {0x60, 0xCC, 0x6F};

    // trame codant une température de 19.6°C avec un chesksum incorrect
    uint8_t frameTChksNOK[] = {0x60, 0xCC, 0x6E};

    // Regrouper les trames dans un tableau pour pouvoir le parcourir
    // avec une boucle
    uint8_t * frames[] = {
        frameHChksOK
        , frameHChksNOK
        , frameTChksOK
        , frameTChksNOK
    };

    float valeur;

    // Parcourir le tableau de trames et afficher pour chacune
    // le résultat de son décodage
    for(int i = 0; i < sizeof(frames)/sizeof(uint8_t *); i++) {
        valeur = getSHT20Value(frames [ i ]);

        printf("Décodage trame n°%d : %+04.1f\n", i+1, valeur);
    }


    return 0;
}