golang et SPI - essayant init RF522 lecteur

Question

J'ai un simple code Python qui fait initialiser MFRC522 appareil correctement:

import spidev 

    mode_reset = 0x0F 

    def spi_transfer(data): 
     r = spi.xfer2(data) 
     return r 

    def dev_write(address, value): 
     r = spi_transfer([(address << 1) & 0x7E, value]) 
     print(">>",[(address << 1) & 0x7E, value], r) 
     return r 

    def reset(): 
     dev_write(0x01, mode_reset) 

    spi = spidev.SpiDev() 
    spi.open(0, 0) 
    spi.max_speed_hz = 1000000 
    print(spi.mode, spi.bits_per_word, spi.lsbfirst) 
    reset() 

qui fonctionne parfaitement bien - il renvoie le code de commande retour 15, mais la même routine d'initialisation mis en œuvre Go ne fonctionne pas vraiment:

package main 

    import (
     "fmt" 
     "golang.org/x/exp/io/spi" 
     "log" 
    ) 

    func main() { 

     spiDev, err := spi.Open(&spi.Devfs{ 
      Dev:  "/dev/spidev0.0", 
      Mode:  spi.Mode(spi.Mode0), 
      MaxSpeed: int64(1000000), 
     }) 

     spiDev.SetMode(spi.Mode0) 
     spiDev.SetBitOrder(spi.MSBFirst) 
     spiDev.SetBitsPerWord(8) 

     if err != nil { 
      log.Fatal(err) 
     } 

     writeSpiData := func(dataIn []byte) (out []byte, err error) { 
      out = make([]byte, len(dataIn)) 
      err = spiDev.Tx(dataIn, out) 
      return 
     } 

     devWrite := func(address int, data byte) (err error) { 
      newData := [2]byte{(byte(address) << 1) & 0x7E, data} 
      readBuf, err := writeSpiData(newData[0:]) 
      fmt.Println(">>", newData, readBuf) 
      return 
     } 

     if err != nil { 
      log.Fatal(err) 
     } 

     devWrite(0x01, 0x0F) 

     fmt.Println("Done") 

    } 

celui-ci retourne [0 0] ce qui est faux. Est-ce que quelqu'un sait ce qui pourrait être mauvais là-bas?

Answer 1

Il semble que le module SPI de Go distribution ne fonctionne pas comme prévu. J'ai fait quelques recherches en utilisant un analyseur logique et j'ai réalisé que la couche de commande SPI de exp/io/spi ne génère pas les commandes appropriées.

Le code source:

package main 

import (
    "fmt" 
    "golang.org/x/exp/io/spi" 
    "log" 
) 

func main() { 

    spiDev, err := spi.Open(&spi.Devfs{ 
     Dev:  "/dev/spidev0.0", 
     MaxSpeed: int64(1000000), 
    }) 

    spiDev.SetMode(spi.Mode0) 
    spiDev.SetBitOrder(spi.MSBFirst) 
    spiDev.SetBitsPerWord(8) 

    if err != nil { 
     log.Fatal(err) 
    } 

    writeSpiData := func(dataIn []byte) (out []byte, err error) { 
     out = make([]byte, len(dataIn)) 
     err = spiDev.Tx(dataIn, out) 
     return 
    } 

    devWrite := func(address int, data byte) (err error) { 
     newData := [2]byte{(byte(address) << 1) & 0x7E, data} 
     readBuf, err := writeSpiData(newData[0:]) 
     fmt.Println(">>", newData, readBuf) 
     return 
    } 

    if err != nil { 
     log.Fatal(err) 
    } 

    devWrite(0x01, 0x0F) 

    fmt.Println("Done") 

} 

Les données résultantes journal:

maintenant avec un autre pilote, https://github.com/ecc1/spi le code ressemble:

package main 

import (
    "fmt" 
    "log" 
    "github.com/ecc1/spi" 
) 

func main() { 

    spiDev, err := spi.Open("/dev/spidev0.0", 1000000, 0) 

    spiDev.SetMode(0) 
    spiDev.SetBitsPerWord(8) 
    spiDev.SetLSBFirst(false) 
    spiDev.SetMaxSpeed(1000000) 

    if err != nil { 
     log.Fatal(err) 
    } 

    writeSpiData := func(dataIn []byte) (err error) { 
     err = spiDev.Transfer(dataIn) 
     return 
    } 

    devWrite := func(address int, data byte) (err error) { 
     newData := [2]byte{(byte(address) << 1) & 0x7E, data} 
     fmt.Print("<< ", newData, " ") 
     err = writeSpiData(newData[0:]) 
     fmt.Println(">>", newData) 
     return 
    } 

    if err != nil { 
     log.Fatal(err) 
    } 

    devWrite(0x01, 0x0F) 

    if err != nil { 
     log.Fatal(err) 
    } 

} 

Et le résultat le vidage de protocole est correct:

impression