Reading internal temperature of an ADC that returns 3 databytes in two's complement (micropython) - bit-manipulation

Question

As the title suggests, I'm trying to read the internal temperature of an ADC (The ADS1235 from Texas Instrument to be precise) using the raspberry Pi Pico running micropython.
The SPI communication between the Pico an the ADC is working fine, I've used an oscilloscope to measure and check.
The problem arises when I have to manipulate the 3 data bytes I receive form the ADC, and turn it into a number which can be used in calculating the internal temperature.
Picture shows the 3 data bytes I receive when I issue the "Read Data command".
The data is received in Twos complement MSB first. I've tried multiple ways to go from a 24-bit twos complement binary string to an negative or positive number.
A positive number calculation works fine, but when I try a negative number (where the most significant bit is 1) it doesn't work. I have a feeling that there must exist some function or easier way to do the conversion, but I haven't been able to find it.
I've attached the code of my current converter function and the main section where I simulate that the ADC has send 3 data bytes in the following order: [0x81, 0x00, 0x00]
As well as the output when the code has run.
import string
def twos_comp_to_decimal(adcreading):
"""compute the int value of 2's complement 24-bit number"""
"""https://www.exploringbinary.com/twos-complement-converter/ look at "implementation" section"""
"""https://note.nkmk.me/en/python-bit-operation/#:~:text=Bitwise%20operations%20in%20Python%20%28AND%2C%20OR%2C%2
0XOR%2C%20NOT%2C,NOT%2C%20invert%3A%20~%206%20Bit%20shifts%3A%20%3C%3C%2C%20%3E%3E"""
signbit = False # Assume adc-reading is positive from the beginning
if adcreading >= 0b100000000000000000000000:
signbit = True
print("negative signbit")
if signbit:
print("inv string")
negativval = bin(~adcreading & 0b011111111111111111111111)
negativval = int(negativval)
negativval += 0b000000000000000000000001
negativval *= -1
return negativval
return adcreading
if __name__ == '__main__':
# tempdata = [0x80, 0xFF, 0x80]
tempdata = [0x81, 0x00, 0x00]
print("Slicing 3 databytes into one 24-bit number")
adc24bit = int.from_bytes(bytearray(tempdata), "big")
print(adc24bit)
print(hex(adc24bit))
print(bin(adc24bit))
print(twos_comp_to_decimal(adc24bit))
# print("Integer value: {}".format(adc24bit))
#temperatureC = ((adc24bit - 122.400) / 420) + 25
#print("Temp in celcius: {}".format(temperatureC))

Answer 1

I wrote this function to do the conversion from 24 bit written in two's complement to decimal, the number you provided as an example turned out to be -8323072, I checked this value here: https://www.exploringbinary.com/twos-complement-converter/.
Here is the code I wrote:
# example data
data = [0x81, 0x00, 0x00]
data_bin = bytearray(data)
def decimal_from_two_comp(bytearr):
string = ''
for byte in bytearr:
string = string + f'{byte:08b}'
# string with the the 24 bits
print(string)
# conversion from two complement to decimal
decimal = -int(string[0]) * 2**23
for i,num in enumerate(string[1:]):
num = int(num)
decimal += num * 2**(23 - (i + 1))
return decimal
You can check on the wikipedia page for Two's Complement under the section Converting from two's complement representation that the algorithm I provided results in the formula they present in that section.