À propos de cet article

Puisqu'on suppose que vous avez de l'expérience dans les circuits électroniques et que vous connaissez les mots GPIO et I2C, nous omettons le glossaire de ces domaines.

Qu'est-ce que USBGPIO8?

Un appareil capable de contrôler GPIO via une communication série La carte USB GPIO (entrée / sortie numérique) de Numato Labs peut être achetée auprès d'Elefine au Japon. https://www.elefine.jp/SHOP/USBGPIO8.html Il est également livré avec un convertisseur AD, ce qui est pratique pour diverses expériences unitaires.

À propos de la communication I2C

http://www.picfun.com/f1/f06.html Cette explication est très facile à comprendre.

Que faire

Contrôlez la communication série avec python, contrôlez USBGPIO8, écrivez 1 octet dans l'EEPROM, puis vérifiez qu'elle est lue et écrite. L'EEPROM utilise 24LC64. 24LC64 est ce produit → http://akizukidenshi.com/catalog/g/gI-00194/

Préparation du matériel

Soit SDA le port 0 de USBGPIO8. Soit SCL le port 1 de USBGPIO8. Tirez avec 10 kΩ chacun. Il est connecté sur la planche à pain avec la configuration ci-dessus.

GPIO8_I2C_回路図.png

À propos des commandes USBGPIO8

Vous pouvez télécharger le manuel sur le site Web d'Elefine ou sur le site officiel, veuillez donc vous y référer pour plus de détails. Nous vous recommandons d'effectuer des expériences de contrôle depuis le début en utilisant un logiciel de terminal série tel que Teraterm au lieu du contrôle de programme.

gpio [command] [arg]\r

Le format est, arg peut ou non être présent, veillez à ne pas oublier le \ r de fin. Lorsque vous envoyez une commande d'écriture

[Commande envoyée]\n\r>
#Par exemple gpio set 0\n\r>

Est renvoyé avec une invite attachée à la commande. Aussi, lorsque vous envoyez une commande de lecture

[Commande envoyée]\n\r[Valeur de retour]\n\r>
#Par exemple gpio lire 0\n\r1\n\r>
# \n\1 pris en sandwich entre r est la valeur de retour

Sera retourné avec une valeur de retour et une invite.

Contrôle GPIO LOW-HIGH

Utilisez la commande clear pour définir le port 0 sur LOW

SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio clear 0\r".encode())

Utilisez la commande set pour définir le port 0 sur HIGH

SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio set 0\r".encode())

commander

Définissez le délai comme timeout = 0.01, sinon il ne renverra pas de réponse pour le reste de votre vie, il est donc préférable de le définir.

Lecture GPIO

Pour lire l'état LOW-HIGH du port 0

SerialInstance = serial.Serial("COM4", 115200, timeout=0.01)
SerialInstance.write("gpio read 0\r".encode())

ça ira

gpio read 0\n\r0\n\r>

Si la réponse est renvoyée, l'état GPIO est 0 (FAIBLE).

Structure du programme

0=LOW 1=HIGH 2 = horloge de lecture Est défini comme. Créez un tableau selon la définition et contrôlez SCL et SDA en fonction du tableau.

Exemple Lors de l'écriture de 1 octet Adresse de périphérique EEPROM 0x50 Ecrire l'adresse 0xa0 Ecrire les données 0x33 Sous cette condition, créez le tableau suivant

[
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
]

Expliquez chaque ligne [1, 0, 1, 0, 0, 0, 0, 0, 2] Les 7 premiers bits représentent l'adresse de 0x50, le 8ème bit est le drapeau d'écriture et le 9ème bit est la lecture de ACK. [0, 0, 0, 0, 0, 0, 0, 0, 2] Les 8 premiers bits sont l'octet supérieur de l'adresse d'écriture, et le 9ème bit est la lecture de ACK. [1, 0, 1, 0, 0, 0, 0, 0, 2] Les 8 premiers bits sont les octets inférieurs de l'adresse d'écriture, et le 9ème bit est la lecture de ACK. [0, 0, 1, 1, 0, 0, 1, 1, 2] Les 8 premiers bits sont des données de 1 octet à écrire et le 9ème bit est une lecture ACK.

Lors de la lecture d'un octet suivant

[
1, 0, 1, 0, 0, 0, 0, 1, 0,
2, 2, 2, 2, 2, 2, 2, 2, 1
]

Expliquez chaque ligne [1, 0, 1, 0, 0, 0, 0, 0, 0] Les 7 premiers bits représentent l'adresse de 0x50, le 8ème bit est le drapeau de lecture et le 9ème bit est la transmission de ACK. [2, 2, 2, 2, 2, 2, 2, 2, 1] Les 8 premiers bits sont lus et le 9e bit est une transmission NOACK (notification de fin de lecture)

Le motif SDA est agencé comme décrit ci-dessus, et l'horloge et les données sont transmises / reçues selon l'agencement.

Code source

# 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 #Depuis le début\Parce qu'il a r+Pas 2+1 faire
    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
    #Lisez avec précision le nombre de caractères renvoyés, et s'il y a un excès ou une carence d'un seul caractère, l'état d'attente de réponse continuera

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
#Condition de départ:Réglez SDA LOW lorsque SCL est HIGH
#Condition d'arrêt:Réglez SCL sur HIGH, puis SDA sur 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() #Revenir à BAS
    SDA_LOW() #Revenir à BAS
    
    # STOP CONDITION
    SDA_LOW()
    SCL_HIGH()
    SDA_HIGH()
    
    #En attente d'écriture, 5 ms par spécification, mais attendez longtemps
    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() #Revenir à BAS
    SDA_LOW() #Revenir à BAS
    
    # 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() #Revenir à BAS
    SDA_LOW() #Revenir à BAS
    
    # STOP CONDITION
    SCL_HIGH()
    SDA_HIGH()
    
    print(parseData(data))
    print("read end")

# defines
constDeviceAddress = 0x50 #Suivez les paramètres IC
constDataAdress = 0x0a88 #Déterminez de manière appropriée dans la plage d'adresses de l'IC, cette fois jusqu'à 2 octets (0)-65535) code supposé, une correction de code est requise pour une adresse à 3 octets
constData = 0x44 # 0-Déterminez de manière appropriée dans la plage de 255

def run(comString):
    SerialInit(comString)
    
    WriteProc()
    ReadProc()
    
    SerialEnd()

if __name__ == "__main__":
    run(sys.argv[1])
# python i2c_byte_write_and_read.py COM4

Explication du code source

Comment utiliser

Pour Linux

python i2c_byte_write_and_read.py /dev/ttyUSB0

Pour les fenêtres

python i2c_byte_write_and_read.py COM4

Comment lire la valeur de retour

['0', '0', '0', '0'] #Octet de contrôle ACK, adresse octet supérieur ACK, adresse octet inférieur ACK, écriture de données ACK
write end
['0', '0', '0'] #Octet de contrôle ACK, adresse octet supérieur ACK, adresse octet inférieur ACK
['0', '0', '1', '1', '0', '0', '1', '1'] #Lire l'état 8 bits
read end

La communication I2C est effectuée en contrôlant la communication série avec python (à l'aide d'un périphérique USBGPIO8)