crc | flexible CRC implementation supporting most major algorithms

I was able to figure out the issues. I used this https://crccalc.com/?crc=C5&method=crc32&datatype=hex&outtype=0 to confirm CRC values that I was getting on microcontroller and RPi.

First issue was on microcontroller, where I was not even performing the CRC on the data, instead I was performing on the address where that data was stored.

Second issue was that MCU was performing CRC on the value which was stored in the little-endian form. On RPi also, CRC was being performed on values stored in little-endian form. Hence, since the endianness was same on both the devices, I did not have to reverse the bits or bytes.

After doing these changes, I was able to get correct and same CRC values on both RPi and microcontroller.

As @Mark's suggested in comments, you would have to store the data into another variable/list, for example: recv = spi.xfer2(data). Then you would need to use this recv in your unpack function. Further, you could also use a python library called zlib instead of using a c library (there are other python libraries as well).

Another point, since zlib takes only bytes as input, you would need to convert recv into bytes (here recv is a list; check my code). I modified some of your code.

The two different systems you are comparing have int types of different sizes, and although your code does not use int explicitly, it is used implicitly by the rules of the C language.

On the AVR, ~0U has the type unsigned int (i.e. uint16_t) and a value of 0xFFFF.

On a normal PC, ~0U has the type unsigned int (i.e. uint32_t) and a value of 0xFFFFFFFF.

Like Tom Karzes said, you should just use ~crc if you want to invert all the bits in the crc variable in a simple, cross-platform way.

CAN contains a 15 bit CRC on the data-link layer. It is handled by the CAN controller and you don't need to do a thing in software, other than checking for errors reported by the controller.

Application layer CRC could be use in some special cases like when you are transferring large amounts of data such as bootloaders. But it isn't necessary for ordinary communication.

The short answer to this is: don't use hostPath.

You are using hostPath to make use of arbitrary disk space available on the underlying host's volume. hostPath can also be used to read/write any directory path on the underlying host's volume -- which, as you can imagine, should be used with great care.

Have a look at this as an alternative -- https://docs.openshift.com/container-platform/4.8/storage/persistent_storage/persistent-storage-local.html

I have 6 sets of code for 16, 32, 64 bit crc, non-reflected and reflected here. The code is setup for Visual Studio. Comments have been added to the constants which were missing from Intel's github site.

https://github.com/jeffareid/crc

32 bit non-relfected is here:

https://github.com/jeffareid/crc/tree/master/crc32f

You'll need to change the polynomial in crc32fg.cpp, which generates the constants. The polynomial you want is actually:

For one thing, you are not calling __cxa_demangle correctly. Documentation says:

output_buffer
A region of memory, allocated with malloc, of *length bytes, into which the demangled name is stored. If output_buffer is not long enough, it is expanded using realloc. output_buffer may instead be NULL; in that case, the demangled name is placed in a region of memory allocated with malloc.

You are passing a stack buffer instead. Get rid of it (and the pointless memset), and do this instead:

The following parameters produce the desired result 280ACDA5: