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.
This commit is contained in:
Chiara
parent
4c654ec969
commit
1751076592
2614 changed files with 349009 additions and 0 deletions
|
|
@ -0,0 +1,403 @@
|
|||
# SPDX-FileCopyrightText: 2021 Melissa LeBlanc-Williams for Adafruit Industries
|
||||
#
|
||||
# SPDX-License-Identifier: MIT
|
||||
"""Chip Definition for MCP2221"""
|
||||
|
||||
import os
|
||||
import time
|
||||
import atexit
|
||||
|
||||
import hid
|
||||
|
||||
# Here if you need it
|
||||
MCP2221_HID_DELAY = float(os.environ.get("BLINKA_MCP2221_HID_DELAY", 0))
|
||||
# Use to set delay between reset and device reopen. if negative, don't reset at all
|
||||
MCP2221_RESET_DELAY = float(os.environ.get("BLINKA_MCP2221_RESET_DELAY", 0.5))
|
||||
|
||||
# from the C driver
|
||||
# http://ww1.microchip.com/downloads/en/DeviceDoc/mcp2221_0_1.tar.gz
|
||||
# others (???) determined during driver developement
|
||||
RESP_ERR_NOERR = 0x00
|
||||
RESP_ADDR_NACK = 0x25
|
||||
RESP_READ_ERR = 0x7F
|
||||
RESP_READ_COMPL = 0x55
|
||||
RESP_READ_PARTIAL = 0x54 # ???
|
||||
RESP_I2C_IDLE = 0x00
|
||||
RESP_I2C_START_TOUT = 0x12
|
||||
RESP_I2C_RSTART_TOUT = 0x17
|
||||
RESP_I2C_WRADDRL_TOUT = 0x23
|
||||
RESP_I2C_WRADDRL_WSEND = 0x21
|
||||
RESP_I2C_WRADDRL_NACK = 0x25
|
||||
RESP_I2C_WRDATA_TOUT = 0x44
|
||||
RESP_I2C_RDDATA_TOUT = 0x52
|
||||
RESP_I2C_STOP_TOUT = 0x62
|
||||
|
||||
RESP_I2C_MOREDATA = 0x43 # ???
|
||||
RESP_I2C_PARTIALDATA = 0x41 # ???
|
||||
RESP_I2C_WRITINGNOSTOP = 0x45 # ???
|
||||
|
||||
MCP2221_RETRY_MAX = 50
|
||||
MCP2221_MAX_I2C_DATA_LEN = 60
|
||||
MASK_ADDR_NACK = 0x40
|
||||
|
||||
|
||||
class MCP2221:
|
||||
"""MCP2221 Device Class Definition"""
|
||||
|
||||
VID = 0x04D8
|
||||
PID = 0x00DD
|
||||
|
||||
GP_GPIO = 0b000
|
||||
GP_DEDICATED = 0b001
|
||||
GP_ALT0 = 0b010
|
||||
GP_ALT1 = 0b011
|
||||
GP_ALT2 = 0b100
|
||||
|
||||
def __init__(self):
|
||||
self._hid = hid.device()
|
||||
self._hid.open(MCP2221.VID, MCP2221.PID)
|
||||
# make sure the device gets closed before exit
|
||||
atexit.register(self.close)
|
||||
if MCP2221_RESET_DELAY >= 0:
|
||||
self._reset()
|
||||
self._gp_config = [0x07] * 4 # "don't care" initial value
|
||||
for pin in range(4):
|
||||
self.gp_set_mode(pin, self.GP_GPIO) # set to GPIO mode
|
||||
self.gpio_set_direction(pin, 1) # set to INPUT
|
||||
|
||||
def close(self):
|
||||
"""Close the hid device. Does nothing if the device is not open."""
|
||||
self._hid.close()
|
||||
|
||||
def __del__(self):
|
||||
# try to close the device before destroying the instance
|
||||
self.close()
|
||||
|
||||
def _hid_xfer(self, report, response=True):
|
||||
"""Perform HID Transfer"""
|
||||
# first byte is report ID, which =0 for MCP2221
|
||||
# remaing bytes = 64 byte report data
|
||||
# https://github.com/libusb/hidapi/blob/083223e77952e1ef57e6b77796536a3359c1b2a3/hidapi/hidapi.h#L185
|
||||
self._hid.write(b"\0" + report + b"\0" * (64 - len(report)))
|
||||
time.sleep(MCP2221_HID_DELAY)
|
||||
if response:
|
||||
# return is 64 byte response report
|
||||
return self._hid.read(64)
|
||||
return None
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# MISC
|
||||
# ----------------------------------------------------------------
|
||||
def gp_get_mode(self, pin):
|
||||
"""Get Current Pin Mode"""
|
||||
return self._hid_xfer(b"\x61")[22 + pin] & 0x07
|
||||
|
||||
def gp_set_mode(self, pin, mode):
|
||||
"""Set Current Pin Mode"""
|
||||
# already set to that mode?
|
||||
mode &= 0x07
|
||||
if mode == (self._gp_config[pin] & 0x07):
|
||||
return
|
||||
# update GP mode for pin
|
||||
self._gp_config[pin] = mode
|
||||
# empty report, this is safe since 0's = no change
|
||||
report = bytearray(b"\x60" + b"\x00" * 63)
|
||||
# set the alter GP flag byte
|
||||
report[7] = 0xFF
|
||||
# add GP setttings
|
||||
report[8] = self._gp_config[0]
|
||||
report[9] = self._gp_config[1]
|
||||
report[10] = self._gp_config[2]
|
||||
report[11] = self._gp_config[3]
|
||||
# and make it so
|
||||
self._hid_xfer(report)
|
||||
|
||||
def _pretty_report(self, register):
|
||||
report = self._hid_xfer(register)
|
||||
print(" 0 1 2 3 4 5 6 7 8 9")
|
||||
index = 0
|
||||
for row in range(7):
|
||||
print("{} : ".format(row), end="")
|
||||
for _ in range(10):
|
||||
print("{:02x} ".format(report[index]), end="")
|
||||
index += 1
|
||||
if index > 63:
|
||||
break
|
||||
print()
|
||||
|
||||
def _status_dump(self):
|
||||
self._pretty_report(b"\x10")
|
||||
|
||||
def _sram_dump(self):
|
||||
self._pretty_report(b"\x61")
|
||||
|
||||
def _reset(self):
|
||||
self._hid_xfer(b"\x70\xAB\xCD\xEF", response=False)
|
||||
self._hid.close()
|
||||
time.sleep(MCP2221_RESET_DELAY)
|
||||
start = time.monotonic()
|
||||
while time.monotonic() - start < 5:
|
||||
try:
|
||||
self._hid.open(MCP2221.VID, MCP2221.PID)
|
||||
except OSError:
|
||||
# try again
|
||||
time.sleep(0.1)
|
||||
continue
|
||||
return
|
||||
raise OSError("open failed")
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# GPIO
|
||||
# ----------------------------------------------------------------
|
||||
def gpio_set_direction(self, pin, mode):
|
||||
"""Set Current GPIO Pin Direction"""
|
||||
if mode:
|
||||
# set bit 3 for INPUT
|
||||
self._gp_config[pin] |= 1 << 3
|
||||
else:
|
||||
# clear bit 3 for OUTPUT
|
||||
self._gp_config[pin] &= ~(1 << 3)
|
||||
report = bytearray(b"\x50" + b"\x00" * 63) # empty set GPIO report
|
||||
offset = 4 * (pin + 1)
|
||||
report[offset] = 0x01 # set pin direction
|
||||
report[offset + 1] = mode # to this
|
||||
self._hid_xfer(report)
|
||||
|
||||
def gpio_set_pin(self, pin, value):
|
||||
"""Set Current GPIO Pin Value"""
|
||||
if value:
|
||||
# set bit 4
|
||||
self._gp_config[pin] |= 1 << 4
|
||||
else:
|
||||
# clear bit 4
|
||||
self._gp_config[pin] &= ~(1 << 4)
|
||||
report = bytearray(b"\x50" + b"\x00" * 63) # empty set GPIO report
|
||||
offset = 2 + 4 * pin
|
||||
report[offset] = 0x01 # set pin value
|
||||
report[offset + 1] = value # to this
|
||||
self._hid_xfer(report)
|
||||
|
||||
def gpio_get_pin(self, pin):
|
||||
"""Get Current GPIO Pin Value"""
|
||||
resp = self._hid_xfer(b"\x51")
|
||||
offset = 2 + 2 * pin
|
||||
if resp[offset] == 0xEE:
|
||||
raise RuntimeError("Pin is not set for GPIO operation.")
|
||||
return resp[offset]
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# I2C
|
||||
# ----------------------------------------------------------------
|
||||
def _i2c_status(self):
|
||||
resp = self._hid_xfer(b"\x10")
|
||||
if resp[1] != 0:
|
||||
raise RuntimeError("Couldn't get I2C status")
|
||||
return resp
|
||||
|
||||
def _i2c_state(self):
|
||||
return self._i2c_status()[8]
|
||||
|
||||
def _i2c_cancel(self):
|
||||
resp = self._hid_xfer(b"\x10\x00\x10")
|
||||
if resp[1] != 0x00:
|
||||
raise RuntimeError("Couldn't cancel I2C")
|
||||
if resp[2] == 0x10:
|
||||
# bus release will need "a few hundred microseconds"
|
||||
time.sleep(0.001)
|
||||
|
||||
# pylint: disable=too-many-arguments,too-many-branches
|
||||
def _i2c_write(self, cmd, address, buffer, start=0, end=None):
|
||||
if self._i2c_state() != 0x00:
|
||||
self._i2c_cancel()
|
||||
|
||||
end = end if end else len(buffer)
|
||||
length = end - start
|
||||
retries = 0
|
||||
|
||||
while (end - start) > 0 or not buffer:
|
||||
chunk = min(end - start, MCP2221_MAX_I2C_DATA_LEN)
|
||||
# write out current chunk
|
||||
resp = self._hid_xfer(
|
||||
bytes([cmd, length & 0xFF, (length >> 8) & 0xFF, address << 1])
|
||||
+ buffer[start : (start + chunk)]
|
||||
)
|
||||
# check for success
|
||||
if resp[1] != 0x00:
|
||||
if resp[2] in (
|
||||
RESP_I2C_START_TOUT,
|
||||
RESP_I2C_WRADDRL_TOUT,
|
||||
RESP_I2C_WRADDRL_NACK,
|
||||
RESP_I2C_WRDATA_TOUT,
|
||||
RESP_I2C_STOP_TOUT,
|
||||
):
|
||||
raise RuntimeError("Unrecoverable I2C state failure")
|
||||
retries += 1
|
||||
if retries >= MCP2221_RETRY_MAX:
|
||||
raise RuntimeError("I2C write error, max retries reached.")
|
||||
time.sleep(0.001)
|
||||
continue # try again
|
||||
# yay chunk sent!
|
||||
while self._i2c_state() == RESP_I2C_PARTIALDATA:
|
||||
time.sleep(0.001)
|
||||
if not buffer:
|
||||
break
|
||||
start += chunk
|
||||
retries = 0
|
||||
|
||||
# check status in another loop
|
||||
for _ in range(MCP2221_RETRY_MAX):
|
||||
status = self._i2c_status()
|
||||
if status[20] & MASK_ADDR_NACK:
|
||||
raise OSError("I2C slave address was NACK'd")
|
||||
usb_cmd_status = status[8]
|
||||
if usb_cmd_status == 0:
|
||||
break
|
||||
if usb_cmd_status == RESP_I2C_WRITINGNOSTOP and cmd == 0x94:
|
||||
break # this is OK too!
|
||||
if usb_cmd_status in (
|
||||
RESP_I2C_START_TOUT,
|
||||
RESP_I2C_WRADDRL_TOUT,
|
||||
RESP_I2C_WRADDRL_NACK,
|
||||
RESP_I2C_WRDATA_TOUT,
|
||||
RESP_I2C_STOP_TOUT,
|
||||
):
|
||||
raise RuntimeError("Unrecoverable I2C state failure")
|
||||
time.sleep(0.001)
|
||||
else:
|
||||
raise RuntimeError("I2C write error: max retries reached.")
|
||||
# whew success!
|
||||
|
||||
def _i2c_read(self, cmd, address, buffer, start=0, end=None):
|
||||
if self._i2c_state() not in (RESP_I2C_WRITINGNOSTOP, 0):
|
||||
self._i2c_cancel()
|
||||
|
||||
end = end if end else len(buffer)
|
||||
length = end - start
|
||||
|
||||
# tell it we want to read
|
||||
resp = self._hid_xfer(
|
||||
bytes([cmd, length & 0xFF, (length >> 8) & 0xFF, (address << 1) | 0x01])
|
||||
)
|
||||
|
||||
# check for success
|
||||
if resp[1] != 0x00:
|
||||
raise RuntimeError("Unrecoverable I2C read failure")
|
||||
|
||||
# and now the read part
|
||||
while (end - start) > 0:
|
||||
for _ in range(MCP2221_RETRY_MAX):
|
||||
# the actual read
|
||||
resp = self._hid_xfer(b"\x40")
|
||||
# check for success
|
||||
if resp[1] == RESP_I2C_PARTIALDATA:
|
||||
time.sleep(0.001)
|
||||
continue
|
||||
if resp[1] != 0x00:
|
||||
raise RuntimeError("Unrecoverable I2C read failure")
|
||||
if resp[2] == RESP_ADDR_NACK:
|
||||
raise RuntimeError("I2C NACK")
|
||||
if resp[3] == 0x00 and resp[2] == 0x00:
|
||||
break
|
||||
if resp[3] == RESP_READ_ERR:
|
||||
time.sleep(0.001)
|
||||
continue
|
||||
if resp[2] in (RESP_READ_COMPL, RESP_READ_PARTIAL):
|
||||
break
|
||||
else:
|
||||
raise RuntimeError("I2C read error: max retries reached.")
|
||||
|
||||
# move data into buffer
|
||||
chunk = min(end - start, 60)
|
||||
for i, k in enumerate(range(start, start + chunk)):
|
||||
buffer[k] = resp[4 + i]
|
||||
start += chunk
|
||||
|
||||
# pylint: enable=too-many-arguments
|
||||
|
||||
def _i2c_configure(self, baudrate=100000):
|
||||
"""Configure I2C"""
|
||||
self._hid_xfer(
|
||||
bytes(
|
||||
[
|
||||
0x10, # set parameters
|
||||
0x00, # don't care
|
||||
0x00, # no effect
|
||||
0x20, # next byte is clock divider
|
||||
12000000 // baudrate - 3,
|
||||
]
|
||||
)
|
||||
)
|
||||
|
||||
def i2c_writeto(self, address, buffer, *, start=0, end=None):
|
||||
"""Write data from the buffer to an address"""
|
||||
self._i2c_write(0x90, address, buffer, start, end)
|
||||
|
||||
def i2c_readfrom_into(self, address, buffer, *, start=0, end=None):
|
||||
"""Read data from an address and into the buffer"""
|
||||
self._i2c_read(0x91, address, buffer, start, end)
|
||||
|
||||
def i2c_writeto_then_readfrom(
|
||||
self,
|
||||
address,
|
||||
out_buffer,
|
||||
in_buffer,
|
||||
*,
|
||||
out_start=0,
|
||||
out_end=None,
|
||||
in_start=0,
|
||||
in_end=None,
|
||||
):
|
||||
"""Write data from buffer_out to an address and then
|
||||
read data from an address and into buffer_in
|
||||
"""
|
||||
self._i2c_write(0x94, address, out_buffer, out_start, out_end)
|
||||
self._i2c_read(0x93, address, in_buffer, in_start, in_end)
|
||||
|
||||
def i2c_scan(self, *, start=0, end=0x79):
|
||||
"""Perform an I2C Device Scan"""
|
||||
found = []
|
||||
for addr in range(start, end + 1):
|
||||
# try a write
|
||||
try:
|
||||
self.i2c_writeto(addr, b"\x00")
|
||||
except OSError: # no reply!
|
||||
# We got a NACK, which could be correct
|
||||
continue
|
||||
# store if success
|
||||
found.append(addr)
|
||||
return found
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# ADC
|
||||
# ----------------------------------------------------------------
|
||||
def adc_configure(self, vref=0):
|
||||
"""Configure the Analog-to-Digital Converter"""
|
||||
report = bytearray(b"\x60" + b"\x00" * 63)
|
||||
report[5] = 1 << 7 | (vref & 0b111)
|
||||
self._hid_xfer(report)
|
||||
|
||||
def adc_read(self, pin):
|
||||
"""Read from the Analog-to-Digital Converter"""
|
||||
resp = self._hid_xfer(b"\x10")
|
||||
return resp[49 + 2 * pin] << 8 | resp[48 + 2 * pin]
|
||||
|
||||
# ----------------------------------------------------------------
|
||||
# DAC
|
||||
# ----------------------------------------------------------------
|
||||
def dac_configure(self, vref=0):
|
||||
"""Configure the Digital-to-Analog Converter"""
|
||||
report = bytearray(b"\x60" + b"\x00" * 63)
|
||||
report[3] = 1 << 7 | (vref & 0b111)
|
||||
self._hid_xfer(report)
|
||||
|
||||
# pylint: disable=unused-argument
|
||||
def dac_write(self, pin, value):
|
||||
"""Write to the Digital-to-Analog Converter"""
|
||||
report = bytearray(b"\x60" + b"\x00" * 63)
|
||||
report[4] = 1 << 7 | (value & 0b11111)
|
||||
self._hid_xfer(report)
|
||||
|
||||
# pylint: enable=unused-argument
|
||||
|
||||
|
||||
mcp2221 = MCP2221()
|
||||
Loading…
Add table
Add a link
Reference in a new issue