Parity check von 32-Bit Wert

[Jens K. (mister232)]

Hallo Leute,

ich verwende in meiner Schaltung einen LTC2418 ADC, welcher über SPI mit 
meinem Mikrocontroller kommuniziert. Das funktioniert soweit auch alles 
sehr gut. Nun bietet das Protokoll des LTC2418 die Möglichkeit die 
Parität der Nachricht zu prüfen, diese muss immer "even" sein. Dazu habe 
ich folgende Funktion geschrieben, welche die Parität eines 32-Bit 
Wertes prüfen soll:

// Function, which checks the parity of a received message from the ADC
uint8_t check_parity(uint32_t adc_message)
{
  unsigned int count = 0, pos, check_bit = 1;


  // Calculate parity sum
  for(pos = 0; pos < 32; pos++)
  {
    // Check if the bit at the actual position is 1
    if(adc_message & (check_bit << pos))
    {
      count++;
    }
  }

  
  // If parity is odd return 0
  if(count % 2)
  {
    return 0;
  }

  return 1;
}

Leider ergibt jede Nachricht "odd". Liegt es an meinem Code oder scheint 
es da noch Probleme beim Empfang der Nachricht zu geben?

[Peter II (Gast)]

(check_bit << pos)

geht auf einer 16bit CPU auch nur bis 16bit.

[H.Joachim S. (crazyhorse)]

Check_bit dürfe etwas knapp bemessen sein.

[Falk B. (falk)]

@Jens K. (mister232)

>sehr gut. Nun bietet das Protokoll des LTC2418 die Möglichkeit die
>Parität der Nachricht zu prüfen, diese muss immer "even" sein.

>// Function, which checks the parity of a received message from the ADC
>uint8_t check_parity(uint32_t adc_message)
{
>  unsigned int count = 0, pos, check_bit = 1;

check_bit muss auch uint32 sein, es sei denn, du hast einen 32 Bit uC, 
dann ist dort int auch 32 Bit breit.
Dann sollte deine Funktion laufen.

Allerdings ist sie reichlich lahm, vor allem auf einem kleinen uC. So 
geht es besser.

uint8_t check_parity(uint32_t adc_message)
{
  int parity, i;

  // Calculate parity sum
  for(i=0, parity=0; i < 32; i++, adc_message>>=1)
  {
    // Check if bit #0 is 1
    if(adc_message & 1)
    {
      parity++;
    }
  }

  if(parity & 1)
  {
    return 0;  // parity is odd, return 0 (error)
  }

  return 1;
}

Noch schneller und besser ist es so, zumindest auf einer 32 Bit CPU.

uint8_t check_parity(uint32_t adc_message)
{

  adc_message = adc_message ^ (adc_message>>16);
  adc_message = adc_message ^ (adc_message>>8);
  adc_message = adc_message ^ (adc_message>>4);
  adc_message = adc_message ^ (adc_message>>2);
  adc_message = adc_message ^ (adc_message>>1);

  if (adc_message & 1) {
  return 0;    // odd parity, error
  };

  return 1;    // even parity, OK
}

Auf einer kleinen CPU könnte eine 16/8 Bit Hilfsvariable die 
Geschwindigkeit erhöhen, falls der Compiler das nicht clever allein 
erkennt.

uint8_t check_parity(uint32_t adc_message)
{

  uint16_t tmp16;
  uint8_t tmp8;

  tmp16 = adc_message ^ (adc_message>>16);
  tmp8  = tmp16 ^ (tmp16>>8);
  tmp8  = tmp8  ^ (tmp8>>4);
  tmp8  = tmp8  ^ (tmp8>>2);
  tmp8  = tmp8  ^ (tmp8>>1);

  if (tmp8 & 1) {
  return 0;    // odd parity, error
  };

  return 1;    // even parity, OK
}

[Jens K. (mister232)]

Danke für eure antworten, werde es nachher mal ausprobieren und mich 
wieder melden

[Johann L. (gjlayde)]

Mit GCC:

#include <stdint.h>

uint8_t get_parity (uint32_t x)
{
#if defined(__GNUC__) && (__SIZEOF_INT__ == 4)
    return __builtin_parity (x);
#elif defined(__GNUC__) && (__SIZEOF_LONG__ == 4)
    return __builtin_parityl (x);
#else
#error
#endif
}

[Falk B. (falk)]

Schön, aber da lernt der OP noch weniger.

[Eric B. (beric)]

Oder so:

uint8_t check_parity(uint32_t adc_message)
{
  int i;
  uint8_t parity = 1;

  // Calculate parity sum
  for(i=0; i < 32; i++, adc_message>>=1)
  {
    parity ^= (uint8_t)(adc_message & 1);
  }

  return parity;
}