mia/abschlussarbeit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

MikrofonSensor und TemperaturSenor die zwei Python programme funktionieren. mit den jeweiligen 2 json Datein. Beim TemperaturSensor wird im Terminal keine Wertre ausgegeben aber in der json Datei kann man die Temp und Hum sehen.

Browse source
This commit is contained in:
Chiara 2025-05-28 14:53:44 +02:00
parent 4c654ec969
commit 1751076592
2614 changed files with 349009 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

306
lib/python3.11/site-packages/adafruit_platformdetect/revcodes.py Normal file
View file

@ -0,0 +1,306 @@
# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
#
# SPDX-License-Identifier: MIT
"""
`adafruit_platformdetect.revcodes`
================================================================================
Class to help with Raspberry Pi Rev Codes
* Author(s): Melissa LeBlanc-Williams
Implementation Notes
--------------------
**Software and Dependencies:**
* Linux and Python 3.7 or Higher
Data values from https://github.com/raspberrypi/documentation/blob/develop/
documentation/asciidoc/computers/raspberry-pi/revision-codes.adoc#new-style-revision-codes
"""
NEW_OVERVOLTAGE = (
"Overvoltage allowed",
"Overvoltage disallowed",
)
NEW_OTP_PROGRAM = (
"OTP programming is allowed",
"OTP programming is disallowed",
)
NEW_OTP_READ = (
"OTP reading is allowed",
"OTP reading is disallowed",
)
NEW_WARRANTY_BIT = (
"Warranty is intact",
"Warranty has been voided by overclocking",
)
NEW_REV_STYLE = (
"Old-style revision",
"New-style revision",
)
NEW_MEMORY_SIZE = (
"256MB",
"512MB",
"1GB",
"2GB",
"4GB",
"8GB",
)
NEW_MANUFACTURER = (
"Sony UK",
"Egoman",
"Embest",
"Sony Japan",
"Embest",
"Stadium",
)
NEW_PROCESSOR = (
"BCM2835",
"BCM2836",
"BCM2837",
"BCM2711",
"BCM2712",
)
PI_TYPE = {
0x00: "A",
0x01: "B",
0x02: "A+",
0x03: "B+",
0x04: "2B",
0x05: "Alpha (early prototype)",
0x06: "CM1",
0x08: "3B",
0x09: "Zero",
0x0A: "CM3",
0x0B: "Custom",
0x0C: "Zero W",
0x0D: "3B+",
0x0E: "3A+",
0x0F: "Internal use only",
0x10: "CM3+",
0x11: "4B",
0x12: "Zero 2 W",
0x13: "400",
0x14: "CM4",
0x15: "CM4S",
0x17: "5",
0x18: "CM5",
0x19: "500",
0x1A: "CM5 Lite",
}
OLD_MANUFACTURER = (
"Sony UK",
"Egoman",
"Embest",
"Qisda",
)
OLD_MEMORY_SIZE = ("256MB", "512MB", "256MB/512MB")
NEW_REV_STRUCTURE = {
"overvoltage": (31, 1, NEW_OVERVOLTAGE),
"otp_program": (30, 1, NEW_OTP_PROGRAM),
"otp_read": (29, 1, NEW_OTP_READ),
"warranty": (25, 1, NEW_WARRANTY_BIT),
"rev_style": (23, 1, NEW_REV_STYLE),
"memory_size": (20, 3, NEW_MEMORY_SIZE),
"manufacturer": (16, 4, NEW_MANUFACTURER),
"processor": (12, 4, NEW_PROCESSOR),
"type": (4, 8, PI_TYPE),
"revision": (0, 4, int),
}
OLD_REV_STRUCTURE = {
"type": (0, PI_TYPE),
"revision": (1, float),
"memory_size": (2, OLD_MEMORY_SIZE),
"manufacturer": (3, OLD_MANUFACTURER),
}
OLD_REV_EXTRA_PROPS = {
"warranty": (24, 1, NEW_WARRANTY_BIT),
}
OLD_REV_LUT = {
0x02: (1, 1.0, 0, 1),
0x03: (1, 1.0, 0, 1),
0x04: (1, 2.0, 0, 0),
0x05: (1, 2.0, 0, 3),
0x06: (1, 2.0, 0, 1),
0x07: (0, 2.0, 0, 1),
0x08: (0, 2.0, 0, 0),
0x09: (0, 2.0, 0, 3),
0x0D: (1, 2.0, 1, 1),
0x0E: (1, 2.0, 1, 0),
0x0F: (1, 2.0, 1, 1),
0x10: (3, 1.2, 1, 0),
0x11: (6, 1.0, 1, 0),
0x12: (2, 1.1, 0, 0),
0x13: (3, 1.2, 1, 2),
0x14: (6, 1.0, 1, 2),
0x15: (2, 1.1, 2, 2),
}
class PiDecoder:
"""Raspberry Pi Revision Code Decoder"""
def __init__(self, rev_code):
try:
self.rev_code = int(rev_code, 16) & 0xFFFFFFFF
except ValueError:
print("Invalid revision code. It should be a hexadecimal value.")
def is_valid_code(self):
"""Quickly check the validity of a code"""
if self.is_new_format():
for code_format in NEW_REV_STRUCTURE.values():
lower_bit, bit_size, values = code_format
prop_value = (self.rev_code >> lower_bit) & ((1 << bit_size) - 1)
if not self._valid_value(prop_value, values):
return False
else:
if (
self.rev_code & 0xFFFF
) not in OLD_REV_LUT.keys(): # pylint: disable=consider-iterating-dictionary
return False
for code_format in OLD_REV_STRUCTURE.values():
index, values = code_format
code_format = OLD_REV_LUT[self.rev_code & 0xFFFF]
if index >= len(code_format):
return False
if not self._valid_value(code_format[index], values):
return False
return True
def _get_rev_prop_value(self, name, structure=None, raw=False):
if structure is None:
structure = NEW_REV_STRUCTURE
if name not in structure.keys():
raise ValueError(f"Unknown property {name}")
lower_bit, bit_size, values = structure[name]
prop_value = self._get_bits_value(lower_bit, bit_size)
if not self._valid_value(prop_value, values):
raise ValueError(f"Invalid value {prop_value} for property {name}")
if raw:
return prop_value
return self._format_value(prop_value, values)
def _get_bits_value(self, lower_bit, bit_size):
return (self.rev_code >> lower_bit) & ((1 << bit_size) - 1)
def _get_old_rev_prop_value(self, name, raw=False):
if (
name
not in OLD_REV_STRUCTURE.keys() # pylint: disable=consider-iterating-dictionary
):
raise ValueError(f"Unknown property {name}")
index, values = OLD_REV_STRUCTURE[name]
data = OLD_REV_LUT[self.rev_code & 0xFFFF]
if index >= len(data):
raise IndexError(f"Index {index} out of range for property {name}")
if not self._valid_value(data[index], values):
raise ValueError(f"Invalid value {data[index]} for property {name}")
if raw:
return data[index]
return self._format_value(data[index], values)
@staticmethod
def _format_value(value, valid_values):
if valid_values is float or valid_values is int:
return valid_values(value)
return valid_values[value]
@staticmethod
def _valid_value(value, valid_values):
if valid_values is float or valid_values is int:
return isinstance(value, valid_values)
if isinstance(valid_values, (tuple, list)) and 0 <= value < len(valid_values):
return True
if isinstance(valid_values, dict) and value in valid_values.keys():
return True
return False
def _get_property(self, name, raw=False):
if name not in NEW_REV_STRUCTURE:
raise ValueError(f"Unknown property {name}")
if self.is_new_format():
return self._get_rev_prop_value(name, raw=raw)
if name in OLD_REV_EXTRA_PROPS:
return self._get_rev_prop_value(
name, structure=OLD_REV_EXTRA_PROPS, raw=raw
)
return self._get_old_rev_prop_value(name, raw=raw)
def is_new_format(self):
"""Check if the code is in the new format"""
return self._get_rev_prop_value("rev_style", raw=True) == 1
@property
def overvoltage(self):
"""Overvoltage allowed/disallowed"""
return self._get_property("overvoltage")
@property
def warranty_bit(self):
"""Warranty bit"""
return self._get_property("warranty")
@property
def otp_program(self):
"""OTP programming allowed/disallowed"""
return self._get_property("otp_program")
@property
def otp_read(self):
"""OTP reading allowed/disallowed"""
return self._get_property("otp_read")
@property
def rev_style(self):
"""Revision Code style"""
# Force new style for Rev Style
return self._get_rev_prop_value("rev_style")
@property
def memory_size(self):
"""Memory size"""
return self._get_property("memory_size")
@property
def manufacturer(self):
"""Manufacturer"""
return self._get_property("manufacturer")
@property
def processor(self):
"""Processor"""
return self._get_property("processor")
@property
def type(self):
"""Specific Model"""
return self._get_property("type")
@property
def type_raw(self):
"""Raw Value of Specific Model"""
return self._get_property("type", raw=True)
@property
def revision(self):
"""Revision Number"""
return self._get_property("revision")