Serielle Kommunikationssteuerung mit Python- und SPI-Kommunikation (mit USBGPIO8-Gerät)
Über diesen Artikel
Steuern Sie die serielle Kommunikation mit Python und führen Sie die I2C-Kommunikation durch (mit einem USBGPIO8-Gerät). Lesen Sie daher zuerst die I2C-Ausgabe.
Informationen zur SPI-Kommunikation
Es gibt grundlegende Spezifikationen, aber ich denke, es ist besser, sich auf das Datenblatt für jeden IC zu beziehen. Das Folgende ist eine leicht verständliche Erklärung der allgemeinen SPI-Kommunikation. http://www.picfun.com/f1/f05.html https://lab.fujiele.co.jp/articles/8191/
Hinweis
Das in diesem Artikel verwendete EEPROM (AT93C46) verfügt über CS (Chip Select), das dem Normalwert entgegengesetzt ist. ** HOCH, um die Kommunikation zu starten und NIEDRIG, um die Kommunikation zu beenden. ** **. Im Allgemeinen startet LOW die Kommunikation und HIGH beendet die Kommunikation.
Ich hätte mit einem allgemeinen IC experimentieren sollen, aber ich habe mich für AT93C46 entschieden, da AT93C46 mit 30 Yen unter ICs, die SPI verwenden, am billigsten war und der Artikel daher nicht vielseitig einsetzbar war.
Was ist zu tun
Steuern Sie USBGPIO8 über die serielle Kommunikation mit Python, steuern Sie den IC (EEPROM) über USBGPIO8, schreiben Sie 2 Bytes und lesen Sie dann 2 Bytes. Bestätigen Sie, dass der geschriebene Wert gelesen werden kann.
Schaltplan
CS sei Port 0 von USBGPIO8 Sei SK Port 1 von USBGPIO8 (Uhr) Der 2. Port von USBGPIO8 sei DI Lassen Sie den 3. Port von USBGPIO8 DO sein
Verwendung des EEPROM (AT93C46)
Harte Einstellung
16bit Modus mit Vcc Verbindung von Nr. 6 (ORG) 8-Bit-Modus mit Nr. 6 (ORG) an GND angeschlossen Dieses Mal werden wir im 16-Bit-Modus arbeiten. Im 16-Bit-Modus können 64 Adressen x 2 Bytes, insgesamt 128 Bytes, gespeichert werden.
AT93C46 Befehlssatz
・ EWEN Schreibberechtigungsstatus ・ SCHREIBEN schreiben · Lesen Lesen Dieses Mal werden wir diese 3 Anweisungen verwenden. Zum Schreiben muss beim Start der EWEN-Modus aktiviert werden. Sobald der EWEN-Modus aktiviert ist, wird der Modus beibehalten, bis die Stromversorgung ausgeschaltet wird.
Die übertragenen Daten sind SB ＋ OP ＋ [Daten etc ...] Es dauert die Konfiguration.
SB = [00000001] behoben OP = [????????] Fügen Sie das vom Modus angegebene Muster + Adresse usw. hinzu Wenn Daten usw. vorhanden sind, fügen Sie diese hinzu.
Zeigen Sie ein konkretes Beispiel
- Stellen Sie eine beliebige 0 oder 1 für das Symbol ein
EWEN-Modus
SB[00000001]
OP[00110000]
＞0000000100110000
Und kontinuierlich senden
Schreibmodus
SB[00000001]
OP[010?????]Die unteren 5 Bits sind die Schreibadresse
Höheres Byte[????????]
Unteres Byte[????????]
＞00000001010?????????????????????
Und kontinuierlich senden
LESEModus
SB[00000001]
OP[100?????]Die unteren 5 Bits sind die Leseadresse
Dummy für höherwertiges Byte[00000000]Dummy-Daten von DO zu empfangen
Dummy für unteres Byte[00000000]Dummy-Daten von DO zu empfangen
＞00000001100?????0000000000000000
Und kontinuierlich senden
Programmstruktur
Quellcode
# usbgpio8_spi_read_write_sample.py
import serial
import sys
import time
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
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 CS_LOW():
gpioLow(0)
def CS_HIGH():
gpioHigh(0)
def SCK_LOW():
gpioLow(1)
def SCK_HIGH():
gpioHigh(1)
def DI_LOW():
gpioLow(2)
def DI_HIGH():
gpioHigh(2)
def READ_DATA():
return gpioRead(3)
def parseData(all):
res = []
for l in all:
a = l.split("\n\r")
res.append(a[1])
return res
def SPI_CommandExec(cmd):
# start condition
size = len(cmd)
data = []
SCK_LOW()
for i in range(size):
d = cmd[i]
if d == 0:
DI_LOW()
elif d == 1:
DI_HIGH()
SCK_HIGH()
if d == 2:
b = READ_DATA()
data.append(b)
SCK_LOW()
return parseData(data)
def WriteBytes(addr, buffer1, buffer2):
# EWEN command
SB = ByteToLH(0b00000001)
OP = ByteToLH(0b00110000)
cmdEWEN = SB + OP
# exec
CS_HIGH()
resEWEN = SPI_CommandExec(cmdEWEN)
CS_LOW()
# write command
SB = ByteToLH(0b00000001)
OP = ByteToLH(0b01000000 | (addr & 0x3f))
buffer1 = ByteToLH(buffer1)
buffer2 = ByteToLH(buffer2)
cmdWrite = SB + OP + buffer1 + buffer2
# exec
CS_HIGH()
resWrite = SPI_CommandExec(cmdWrite)
CS_LOW()
#Warten auf das Schreiben, 5 ms nach Spezifikation, aber lange warten
time.sleep(0.01)
response = resEWEN + resWrite
return response
def ReadBytes(addr):
# create command
SB = ByteToLH(0b00000001)
OP = ByteToLH(0b10000000 | (addr & 0x3f))
buffer1 = [2] * 8
buffer2 = [2] * 8
cmd = SB + OP + buffer1 + buffer2
CS_HIGH()
response = SPI_CommandExec(cmd)
CS_LOW()
return response
def Test_WriteBytes(comString):
SerialInit(comString)
response = WriteBytes(7, 0x34, 0x56)
print(response)
SerialEnd()
def Test_ReadBytes(comString):
SerialInit(comString)
response = ReadBytes(7)
print(response)
SerialEnd()
def run(comString):
Test_WriteBytes(comString)
Test_ReadBytes(comString)
if __name__ == "__main__":
run(sys.argv[1])
# python usbgpio8_spi_read_write_sample.py COM4
Wie benutzt man
Für Linux
python usbgpio8_spi_read_write_sample.py /dev/ttyUSB0
Für Windows
python usbgpio8_spi_read_write_sample.py COM4
Lesen des Rückgabewerts
[] #Nichts besonderes beim Schreiben
['0', '0', '1', '1', '0', '1', '0', '0', '0', '1', '0', '1', '0', '1', '1', '0'] #Die ersten 8 Bits sind das gelesene obere Byte und die folgenden 8 Bits sind das gelesene untere Byte.
das ist alles
Recommended Posts