Contrôle de la communication série avec communication python et SPI (à l'aide d'un périphérique USBGPIO8)

À propos de cet article

Contrôlez la communication série avec python et effectuez la communication I2C (à l'aide d'un périphérique USBGPIO8), veuillez donc d'abord lire l'édition I2C.

À propos de la communication SPI

Il y a des spécifications de base, mais je pense qu'il vaut mieux se référer à la fiche technique de chaque IC. Ce qui suit est une explication facile à comprendre de la communication SPI générale. http://www.picfun.com/f1/f05.html https://lab.fujiele.co.jp/articles/8191/

Mise en garde

L'EEPROM (AT93C46) utilisé dans cet article a CS (sélection de puce) opposé à la normale. ** HAUT pour démarrer la communication et BAS pour terminer la communication. ** ** Généralement, LOW démarre la communication et HIGH termine la communication.

J'aurais dû expérimenter un circuit intégré général, mais j'ai choisi AT93C46 car AT93C46 était le moins cher à 30 yens parmi les circuits intégrés utilisant SPI, et par conséquent, l'article manquait de polyvalence.

Que faire

Contrôlez USBGPIO8 en utilisant la communication série avec python, contrôlez l'IC (EEPROM) depuis USBGPIO8, écrivez 2 octets, puis lisez 2 octets Confirmez que la valeur écrite peut être lue.

schéma

Soit CS le port 0 de USBGPIO8 Soit SK le port 1 de USBGPIO8 (horloge) Laissez le 2ème port de USBGPIO8 être DI Laissez le 3ème port d'USBGPIO8 faire

Comment utiliser EEPROM (AT93C46)

Réglage dur

Mode 16 bits avec connexion Vcc du n ° 6 (ORG) Mode 8 bits avec n ° 6 (ORG) connecté à GND Cette fois, nous fonctionnerons en mode 16 bits. En mode 16 bits, 64 adresses x 2 octets, 128 octets au total, peuvent être sauvegardées.

Jeu d'instructions AT93C46

・ Statut d'autorisation d'écriture EWEN ・ ÉCRIRE écrire · Lire lire Cette fois, nous utiliserons ces 3 instructions. Pour écrire, il est nécessaire de régler le mode EWEN au démarrage, une fois qu'il est réglé sur le mode EWEN, le mode est maintenu jusqu'à ce que l'alimentation soit coupée.

Les données transmises sont SB ＋ OP ＋ [Données etc ...] Il faut la configuration.

SB = [00000001] Fixe OP = [????????] Ajouter le motif + l'adresse, etc. spécifiés par le mode S'il y a des données, etc., ajoutez-les.

Montrez un exemple concret

• Définissez n'importe quel 0 ou 1 pour le symbole?

Mode EWEN

SB[00000001]
OP[00110000]
＞0000000100110000
Et envoyer en continu

Mode WRITE

SB[00000001]
OP[010?????]Les 5 bits inférieurs sont l'adresse d'écriture
Octet supérieur[????????]
Octet inférieur[????????]
＞00000001010?????????????????????
Et envoyer en continu

Mode lecture

SB[00000001]
OP[100?????]Les 5 bits inférieurs sont l'adresse de lecture
Dummy pour l'octet de poids fort[00000000]Données factices à recevoir de DO
Dummy pour l'octet inférieur[00000000]Données factices à recevoir de DO
＞00000001100?????0000000000000000
Et envoyer en continu

Structure du programme

Contrôlez la communication série avec python et effectuez la communication I2C (en utilisant un périphérique USBGPIO8), alors reportez-vous à cela.

Code source

# 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 #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

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()
    #En attente d'écriture, 5 ms par spécification, mais attendez longtemps
    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

Comment utiliser

Pour Linux

python usbgpio8_spi_read_write_sample.py /dev/ttyUSB0

Pour les fenêtres

python usbgpio8_spi_read_write_sample.py COM4

Comment lire la valeur de retour

[] #Rien de particulier lors de l'écriture
['0', '0', '1', '1', '0', '1', '0', '0', '0', '1', '0', '1', '0', '1', '1', '0'] #Les 8 premiers bits sont l'octet supérieur lu et les 8 bits suivants sont l'octet inférieur lu.

c'est tout