Die I2C-Kommunikation erfolgt durch Steuerung der seriellen Kommunikation mit Python (über ein USBGPIO8-Gerät).
Über diesen Artikel
Da davon ausgegangen wird, dass Sie Erfahrung mit elektronischen Schaltkreisen haben und die Wörter GPIO und I2C kennen, wird das Glossar dieser Bereiche weggelassen.
Was ist USBGPIO8?
Ein Gerät, das GPIO über serielle Kommunikation steuern kann Die USB-GPIO-Karte (Digital Input / Output) von Numato Labs ist im Versandhandel von Elefine in Japan erhältlich. https://www.elefine.jp/SHOP/USBGPIO8.html Es kommt auch mit einem AD-Wandler, der für verschiedene Einheitenexperimente geeignet ist.
Informationen zur I2C-Kommunikation
http://www.picfun.com/f1/f06.html Diese Erklärung ist sehr leicht zu verstehen.
Was ist zu tun
Steuern Sie die serielle Kommunikation mit Python, steuern Sie USBGPIO8, schreiben Sie 1 Byte in das EEPROM und überprüfen Sie, ob es gelesen und geschrieben wurde. Das EEPROM verwendet 24LC64. 24LC64 ist dieses Produkt → http://akizukidenshi.com/catalog/g/gI-00194/
Hardware-Vorbereitung
SDA sei Port 0 von USBGPIO8. SCL sei Port 1 von USBGPIO8. Mit jeweils 10 kΩ hochziehen. Es wird mit der obigen Konfiguration auf dem Steckbrett angeschlossen.
Informationen zu USBGPIO8-Befehlen
Sie können das Handbuch von der Elefine-Website oder offiziell herunterladen. Weitere Informationen finden Sie hier. Wir empfehlen, dass Sie von Anfang an Steuerungsexperimente mit serieller Terminalsoftware wie Teraterm anstelle der Programmsteuerung durchführen.
gpio [command] [arg]\r
Das Format ist, arg kann vorhanden sein oder nicht, achten Sie darauf, das nachfolgende \ r nicht zu vergessen. Wenn Sie einen Schreibbefehl senden
[Befehl gesendet]\n\r>
#Zum Beispiel gpio setze 0\n\r>
Wird mit einer an den Befehl angehängten Eingabeaufforderung zurückgegeben. Auch wenn Sie einen Lesebefehl senden
[Befehl gesendet]\n\r[Rückgabewert]\n\r>
#Zum Beispiel las gpio 0\n\r1\n\r>
# \n\1 zwischen r ist der Rückgabewert
Wird mit einem Rückgabewert und einer Eingabeaufforderung zurückgegeben.
GPIO LOW-HIGH-Steuerung
Verwenden Sie den Befehl clear, um Port 0 auf LOW zu setzen
SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio clear 0\r".encode())
Verwenden Sie den Befehl set, um Port 0 auf HIGH zu setzen
SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio set 0\r".encode())
Befehl
Stellen Sie das Zeitlimit auf Zeitlimit = 0,01 ein. Andernfalls wird für den Rest Ihres Lebens keine Antwort zurückgegeben. Daher ist es besser, das Zeitlimit festzulegen.
GPIO-Lesung
Zum Lesen des LOW-HIGH-Status von Port 0
SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio read 0\r".encode())
Wird besorgt
gpio read 0\n\r0\n\r>
Wenn die Antwort zurückgegeben wird, ist der GPIO-Status 0 (LOW).
Programmstruktur
0=LOW 1=HIGH 2 = Uhr lesen Ist definiert als. Erstellen Sie ein Array gemäß der Definition und steuern Sie SCL und SDA gemäß dem Array.
Beispiel Beim Schreiben von 1 Byte EEPROM-Geräteadresse 0x50 Schreiben Sie die Adresse 0xa0 Daten schreiben 0x33 Erstellen Sie unter dieser Bedingung das folgende Array
[
1, 0, 1, 0, 0, 0, 0, 0, 2,
0, 0, 0, 0, 0, 0, 0, 0, 2,
1, 0, 1, 0, 0, 0, 0, 0, 2,
0, 0, 1, 1, 0, 0, 1, 1, 2
]
Erklären Sie jede Zeile [1, 0, 1, 0, 0, 0, 0, 0, 2] Die ersten 7 Bits repräsentieren die Adresse von 0x50, das 8. Bit ist das Schreibflag und das 9. Bit ist das Lesen von ACK. [0, 0, 0, 0, 0, 0, 0, 0, 2] Die ersten 8 Bits sind das obere Byte der Schreibadresse, und das 9. Bit ist das Lesen von ACK. [1, 0, 1, 0, 0, 0, 0, 0, 2] Die ersten 8 Bits sind die unteren Bytes der Schreibadresse, und das 9. Bit ist das Lesen von ACK. [0, 0, 1, 1, 0, 0, 1, 1, 2] Die ersten 8 Bits sind zu schreibende 1-Byte-Daten, und das 9. Bit ist ACK-gelesen.
Beim nächsten Lesen von 1 Byte
[
1, 0, 1, 0, 0, 0, 0, 1, 0,
2, 2, 2, 2, 2, 2, 2, 2, 1
]
Erklären Sie jede Zeile [1, 0, 1, 0, 0, 0, 0, 0, 0] Die ersten 7 Bits repräsentieren die Adresse von 0x50, das 8. Bit ist das Leseflag und das 9. Bit ist die Übertragung von ACK. [2, 2, 2, 2, 2, 2, 2, 2, 1] Die ersten 8 Bits werden gelesen, und das 9. Bit ist die NOACK-Übertragung (Benachrichtigung über den Abschluss des Lesens).
Das SDA-Muster ist wie oben beschrieben angeordnet, und der Takt und die Daten werden gemäß der Anordnung gesendet / empfangen.
Quellcode
# i2c_byte_write_and_read.py
import serial
import sys
import time
import threading
SerialInstance = None
def SerialInit(comString):
global SerialInstance
SerialInstance = serial.Serial(comString, 115200, timeout=0.01)
#SerialInstance = serial.Serial(comString, 19200, timeout=0.1)
def SerialEnd():
SerialInstance.close()
def SerialTalk(cmd, response=False):
readLen = len(cmd) + 1 # gpio read 0\n\r #Von Anfang an\Weil es r hat+Nicht 2+Ich mache
if response == True:
readLen += 3 # N\n\r
readLen += 1 # >
cnt = SerialInstance.write(cmd.encode())
res = SerialInstance.read(readLen)
res = res.decode("utf-8").strip()
return res
#Lesen Sie die Anzahl der zurückgegebenen Zeichen genau ab. Wenn nur ein Zeichen zu viel oder zu wenig vorhanden ist, wird der Wartezustand der Antwort fortgesetzt.
def gpioHigh(n):
SerialTalk("gpio set {}\r".format(n))
def gpioLow(n):
SerialTalk("gpio clear {}\r".format(n))
def gpioRead(n):
res = SerialTalk("gpio read {}\r".format(n), response=True)
return res
def ByteToLH(b):
lh = []
for i in range(8):
if (b << i & 128) == 0:
lh.append(0)
else:
lh.append(1)
return lh
def SDA_LOW():
gpioLow(0)
def SDA_HIGH():
gpioHigh(0)
def SCL_LOW():
gpioLow(1)
def SCL_HIGH():
gpioHigh(1)
def READ_DATA():
return gpioRead(0)
def parseData(all):
res = []
for l in all:
a = l.split("\n\r")
res.append(a[1])
return res
# 0 = LOW
# 1 = HIGH
# 2 = READ
#Startbedingung:Stellen Sie SDA LOW ein, während SCL HIGH ist
#Stoppbedingung:Stellen Sie SCL auf HIGH und SDA auf HIGH
def WriteProc():
ctrlByte = ByteToLH(constDeviceAddress << 1)
addrHigh = ByteToLH((constDataAdress >> 8) & 0xff)
addrLow = ByteToLH(constDataAdress & 0xff)
write1Byte = ByteToLH(constData)
cmdWrite = ctrlByte + [2] + addrHigh + [2] + addrLow + [2] + write1Byte + [2]
# START CONDITION
SCL_HIGH()
SDA_LOW()
size = len(cmdWrite)
data = []
for i in range(size):
SCL_LOW()
d = cmdWrite[i]
if d == 0:
SDA_LOW()
elif d == 1:
SDA_HIGH()
SCL_HIGH()
if d == 2:
response = READ_DATA()
data.append(response)
SCL_LOW() #Kehre zu NIEDRIG zurück
SDA_LOW() #Kehre zu NIEDRIG zurück
# STOP CONDITION
SDA_LOW()
SCL_HIGH()
SDA_HIGH()
#Warten auf das Schreiben, 5 ms nach Spezifikation, aber lange warten
time.sleep(0.1)
print(parseData(data))
print("write end")
def ReadProc():
#
#
# set address
ctrlByte = ByteToLH(constDeviceAddress << 1)
addrHigh = ByteToLH((constDataAdress >> 8) & 0xff)
addrLow = ByteToLH(constDataAdress & 0xff)
cmdSetAddress = ctrlByte + [2] + addrHigh + [2] + addrLow + [2]
# START CONDITION
SCL_HIGH()
SDA_LOW()
size = len(cmdSetAddress)
data = []
for i in range(size):
SCL_LOW()
#print(i)
d = cmdSetAddress[i]
if d == 0:
SDA_LOW()
elif d == 1:
SDA_HIGH()
SCL_HIGH()
if d == 2:
response = READ_DATA()
data.append(response)
SCL_LOW() #Kehre zu NIEDRIG zurück
SDA_LOW() #Kehre zu NIEDRIG zurück
# STOP CONDITION
SCL_HIGH()
SDA_HIGH()
print(parseData(data))
#
#
# read data
ctrlByte = ByteToLH((constDeviceAddress << 1) | 0x01)
readByte = [2] * 8
cmdReadByte = ctrlByte + [0] + readByte + [1]
# START CONDITION
SCL_HIGH()
SDA_LOW()
size = len(cmdReadByte)
data = []
for i in range(size):
SCL_LOW()
#print(i)
d = cmdReadByte[i]
if d == 0:
SDA_LOW()
elif d == 1:
SDA_HIGH()
SCL_HIGH()
if d == 2:
response = READ_DATA()
data.append(response)
SCL_LOW() #Kehre zu NIEDRIG zurück
SDA_LOW() #Kehre zu NIEDRIG zurück
# STOP CONDITION
SCL_HIGH()
SDA_HIGH()
print(parseData(data))
print("read end")
# defines
constDeviceAddress = 0x50 #Folgen Sie den IC-Einstellungen
constDataAdress = 0x0a88 #Bestimmen Sie entsprechend innerhalb des Adressbereichs des IC, diesmal bis zu 2 Bytes (0)-65535) Code angenommen, Codekorrektur ist für 3-Byte-Adresse erforderlich
constData = 0x44 # 0-Bestimmen Sie entsprechend im Bereich von 255
def run(comString):
SerialInit(comString)
WriteProc()
ReadProc()
SerialEnd()
if __name__ == "__main__":
run(sys.argv[1])
# python i2c_byte_write_and_read.py COM4
Erklärung des Quellcodes
Wie benutzt man
Für Linux
python i2c_byte_write_and_read.py /dev/ttyUSB0
Für Windows
python i2c_byte_write_and_read.py COM4
Lesen des Rückgabewerts
['0', '0', '0', '0'] #Steuerbyte ACK, Adresse oberes Byte ACK, Adresse unteres Byte ACK, Daten ACK schreiben
write end
['0', '0', '0'] #Steuerbyte ACK, Adresse oberes Byte ACK, Adresse unteres Byte ACK
['0', '0', '1', '1', '0', '0', '1', '1'] #8-Bit-Status lesen
read end
das ist alles
Recommended Posts