Studentenversion des ESY6/A Praktikums "signal_processing".
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

crc.c 3.4KB

1 year ago
1 year ago
1 year ago
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119
  1. #include "system/task_crc.h"
  2. #include "system/data_channel.h"
  3. #include "system/float_word.h"
  4. #include <stdio.h>
  5. // Funktion zur Berechnung des CRC32
  6. void berechne_crc32(uint32_t data, uint32_t * crc);
  7. void crc32( uint32_t data, uint32_t* crc );
  8. int task_crc_run( void * task ) {
  9. crc_config * config = (crc_config*) task;
  10. uint32_t value = config->start;
  11. // Nachfolgende Antworten Lesen den FIFO der ersten Datenquelle aus und multiplizieren
  12. // den jeweils gelesenen Wert mit 4 und speichern das Ergebnis in der Datensenke
  13. for (uint32_t i = 0; i < DATA_CHANNEL_DEPTH; ++i) {
  14. float_word a;
  15. data_channel_read(config->base.sources[0], (uint32_t * ) & a.value );
  16. //if (i<10) {printf("\n Input %i DATA; %x\ CRC: %x\n", i, a.word, value);}
  17. berechne_crc32(a.word, &value); //Startwert jedes Mal, oder mit vorheriger crc starten?
  18. //if (i<10) {printf("\n CRC Zwischenwert Output(%i): %x\n", i, value);}
  19. }
  20. printf("CRC Wert: %x\n", value);
  21. data_channel_write( config->base.sink, value);
  22. return 0;
  23. }
  24. // TODO
  25. // Funktion zur Berechnung des CRC32
  26. void crc32( uint32_t data, uint32_t* crc ) {
  27. uint32_t byte_array[4];
  28. uint32_t reg32 = ~*crc;
  29. byte_array[3] = (uint32_t) (data>>24) & 0x000000FF;
  30. byte_array[2] = (uint32_t) (data>>16) & 0x000000FF;
  31. byte_array[1] = (uint32_t) (data>>8) & 0x000000FF;
  32. byte_array[0] = (uint32_t) (data) & 0x000000FF;
  33. for ( uint32_t i = 0; i < 4; ++i ) {
  34. for ( uint8_t j = 0; j < 8; ++j ) {
  35. if ((reg32&1) != (byte_array[i]&1)) { // != hat Prio 7, & hat Prio 8!
  36. reg32 = (reg32>>1)^CRC32POLY;
  37. }
  38. else {
  39. reg32 >>= 1;
  40. }
  41. byte_array[i] >>= 1;
  42. }
  43. *crc= reg32 ^ 0xffffffff; //inverses Ergebnis, MSB zuerst
  44. }
  45. }
  46. void berechne_crc32(uint32_t data, uint32_t * crc) {
  47. uint32_t bytes[4]; //Reihenfolge richtig?
  48. uint32_t reg32 = ~*crc;
  49. bytes[0] = (uint32_t) (data) & 0x000000FF;
  50. bytes[1] = (uint32_t) (data >>8) & 0x000000FF;
  51. bytes[2] = (uint32_t) (data >>16) & 0x000000FF;
  52. bytes[3] = (uint32_t) (data >>24) & 0x000000FF; //aufffüllen
  53. for (uint32_t i = 0; i < 4; i++) {
  54. //von rechts nch links
  55. for (uint8_t j = 0; j <8; j++) {
  56. // Prüfen, ob das am weitesten rechts stehende Bit von crc 1 ist
  57. if ((reg32 & 1) != (bytes[i] & 1)) { //Wieso crc & 1?
  58. reg32 = (reg32 >> 1)^CRC32POLY; // XOR mit dem Polynom
  59. } else {
  60. reg32 >>= 1;
  61. }
  62. bytes[i]>>=1;
  63. }
  64. *crc = reg32 ^0xFFFFFFFF;
  65. }
  66. }
  67. /*
  68. crc := 0000… (Startwert)
  69. für alle Bits b im Datenstrom:
  70. wenn das am weitesten links stehende Bit von crc 1 ist:
  71. crc := (crc * 2 + b) xor CRC-Polynom
  72. sonst:
  73. crc := crc * 2 + b
  74. crc enthält das Ergebnis.
  75. */
  76. /*
  77. for (uint32_t j = 0; j < 32; j++) {
  78. if (a.word & (1<<31)) {
  79. c.word = (c.word * 2 + ((a.word & (1<<j))>>j)) ^ CRC32POLY;
  80. } else {
  81. c.word = (c.word * 2 + ((a.word & (1<<j))>>j));
  82. }
  83. }
  84. */
  85. /*
  86. const uint8_t bitstream[] = { 1,0,0,0,1,1,0,0 };
  87. const int bitcount = 8;
  88. uint32_t crc32 = 0; // Schieberegister
  89. int main ()
  90. {
  91. for (int i = 0; i < bitcount; i++)
  92. {
  93. if ( ((crc32 >> 31) & 1) != bitstream[i])
  94. crc32 = (crc32 << 1) ^ CRC32POLY;
  95. else
  96. crc32 = (crc32 << 1);
  97. }
  98. printf ("0x%08X\n", crc32);
  99. }
  100. */