Mithilfe von Python-smbus auf einem Raspberry Pi verwechseln mit der syntax

Ich bin versucht, python-smbus auf einem Raspberry Pi für die Kommunikation mit einem accelerometer-MMA7660-chip mit I2C.

Im nachfolgenden code lese ich die Register 0x00, 0x01, 0x02 und 0x03 in der span -, und ich bin immer der exakt gleiche Werte für alle. Blick auf die Werte, und kippen Sie den chip, ich kann sehen, dass Sie alle entsprechen register 0x00, X-Wert zu registrieren.

Ausgabe:

...
1 1 1 2
3 3 3 3
1 1 1 1
59 60 60 60
51 51 51 51
58 58 58 58
3 3 3 3
62 62 62 62
58 58 58 58
62 62 62 62
...

Code:

  import smbus
  import time

  bus = smbus.SMBus(1)
  # I2C address for MMA7660                                                     
  addr = 0x4C
  try:
    bus.write_byte_data(addr, 0x07, 0x00)
    bus.write_byte_data(addr, 0x06, 0x10)
    bus.write_byte_data(addr, 0x08, 0x00)
    bus.write_byte_data(addr, 0x07, 0x01)
  except IOError, err:
    print err

  while True:
    try:
      x = bus.read_byte_data(addr,0x00)
      y = bus.read_byte_data(addr,0x01)
      z = bus.read_byte_data(addr,0x02)
      tr = bus.read_byte_data(addr,0x03)
      print x, y, z, tr
      time.sleep(0.25)
    except:
      print 'exiting...'
      break

Mache ich etwas falsch mit dem smbus-syntax? Ich habe mir die Dokumentation hier.

Habe ich verifiziert, dass der chip funktioniert - ich kann kommunizieren gut mit es mit einem Arduino und dem setzen der Register in der gleichen Reihenfolge wie oben.

Update #1 (28 Jun 2013):

Als pro Sylvain Kommentar, ich füge Oszilloskop-Ausgang für die SDA/SCL-Leitungen für den folgenden code:

bus.write_byte(addr, 0x01)
print bus.read_byte(addr)

Mithilfe von Python-smbus auf einem Raspberry Pi verwechseln mit der syntax

Update #2:

Ich denke, es ist ein bekanntes problem mit I2C am Raspberry Pi - es gibt keine ", Wiederholte Starten".

https://raspberrypi.stackexchange.com/questions/7138/mma8452-i2c-module

Laut der Linux SMBus spec:

SMBus Read Byte:  i2c_smbus_read_byte_data()
============================================

This reads a single byte from a device, from a designated register.
The register is specified through the Comm byte.

S Addr Wr [A] Comm [A] S Addr Rd [A] [Data] NA P

Aber wenn ich es versuchte, die osciiloscope zeigt deutlich ein STOP (P) bevor der Wiederholte Start (S).

Also ich denke, ich bin viel Glück für die Verwendung von I2C-hardware auf dem Pi zu sprechen, um die MMA7760.

InformationsquelleAutor M-V | 2013-06-26

2

wenn Sie Lesen, alle benötigten Register auf einmal, es funktioniert Prima:
```
import smbus
bus = smbus.SMBus(1) 

Register = bus.read_i2c_block_data(0x4c, 0x99,4)
acc_x = Register[0]*1.0
acc_y = Register[1]*1.0
acc_z = Register[2]*1.0
acc_tilt     = Register[3] 
```
Versucht dies mit dem MMA8452 und es hat nicht geholfen. Ich vermute, was auch immer chip Sie war tolerant von unsachgemäßer START/STOP/WIEDERHOLTER-START

InformationsquelleAutor ThomGob
1

Ich bin absolut nicht sicher, ob dies das problem, aber nach den specs p22:

MMA7660FC ist, Lesen Sie es intern gespeichert register-Adresse als Adresse-Zeiger auf die gleiche Weise, die register-Adresse gespeichert
wird als Adress-Zeiger für ein schreiben. Der Zeiger in der Regel auto-Inkremente nach jedem Daten-byte gelesen wird, mit den gleichen Regeln
als für einen schreiben (Tabelle 5). So ein Lesen wird gestartet, indem zuerst die Konfiguration des Gerätes ist die register-Adresse, indem Sie eine schreiben (Abbildung 11)
gefolgt von einem wiederholten start. Der master kann jetzt read 'n' aufeinanderfolgenden bytes von ihm, mit dem ersten Daten-byte gelesen wird, aus der
registrieren Sie sich angesprochen initialisiert register-Adresse.

Soweit ich das verstanden habe, zu "Lesen" aus einem register, Sie haben zu Beginn von schreiben die register-Adresse, und dann blind Lesen ein byte. Ich weiß nicht, ob SMBus.read_byte_data kümmern, dass für Sie, aber Sie könnten versuchen, es manuell:
```
  bus.write_byte(addr,0x00)
  x = bus.read_byte(addr)

  bus.write_byte(addr,0x01)
  y = bus.read_byte_data(addr)

  bus.write_byte(addr,0x02)
  z = bus.read_byte(addr)

  bus.write_byte(addr,0x03)
  tr = bus.read_byte(addr)
```
Vielleicht das würde sogar funktionieren:
```
  bus.write_byte(addr,0x00)

  x = bus.read_byte(addr)
  y = bus.read_byte_data(addr)
  z = bus.read_byte(addr)
  tr = bus.read_byte(addr)
```
Leider weder gearbeitet, aber ich denke, Ihr seid auf dem richtigen Weg. Es ist eine Frage der, herauszufinden, wie dies zu tun mit smbus. Ich wünschte, Sie hatten einen niedrigeren level-Aufrufe für I2C-start/stop/restart, etc. Ich könnte das gleiche zu tun, genau in C und und einem ATmega168 und es funktioniert alles.
Haben Sie ein Oszilloskop oder logical analyzer untersuchen Sie den bus?
Ich habe ein Oszilloskop aber nicht sehr fähig. Ehrlich gesagt, habe ich nicht herausgefunden, wie es zu benutzen für die Analyse von digitalen Wellenformen - Daten geht in eine Zacke.
Sie müssen wahrscheinlich ein DSO zu untersuchen, die Art des Signals.
Danke @Sylvain - ich verbrachte einige Zeit auf, wie mein Umfang zu fangen diese Signale. Ich habe die Signale - bitte teilen Sie irgendwelche Erkenntnisse.

InformationsquelleAutor Sylvain Leroux

Nachdem Sie Ihren Beispiel, als auch für die Klasse geschrieben für den MMA7455, konnte ich Folgendes schreiben:

import smbus
import time
import os
import math

# Define a class for the accelerometer readings
class MMA7660():
    bus = smbus.SMBus(1)
    def __init__(self):
        self.bus.write_byte_data(0x4c, 0x07, 0x00) # Setup the Mode
        self.bus.write_byte_data(0x4c, 0x06, 0x10) # Calibrate
        self.bus.write_byte_data(0x4c, 0x08, 0x00) # Calibrate
        self.bus.write_byte_data(0x4c, 0x07, 0x01) # Calibrate
    def getValueX(self):
        return self.bus.read_byte_data(0x4c, 0x00)
    def getValueY(self):
        return self.bus.read_byte_data(0x4c, 0x01)
    def getValueZ(self):
        return self.bus.read_byte_data(0x4c, 0x02)

mma = MMA7660()

for a in range(1000):
    x = mma.getValueX()
    y = mma.getValueY()
    z = mma.getValueZ()
    print("X=", x)
   print("Y=", y)
   print("Z=", z)
    time.sleep(0.2)
    os.system("clear")

Sollte den trick tun.

InformationsquelleAutor MangoBoy

0

Den Raspberry PI I2C-Kernel-Treiber nicht unterstützt, wiederholt, beginnt für eine bestimmte Zeit. Jedoch, der I2C-Kernel-Treiber wurde aktualisiert und unterstützt nun das wiederholte starten, obwohl diese Funktionalität muss explizit aktiviert werden.

Zu setzen, kombiniert transfers "auf"

sudo sh -c '/bin/echo Y > /sys/module/i2c_bcm2708/parameters/combined'

Zu setzen Sammelüberweisungen "off"

sudo sh -c '/bin/echo N > /sys/module/i2c_bcm2708/parameters/combined'

Informationen finden Sie hier: http://raspberrypi.znix.com/hipidocs/topic_i2c_rs_and_cs.htm

Sobald dies erledigt ist, was regelt, wie viele wiederholte start-Befehle erteilt werden? Wenn ich versuche, mit smbus ist read_i2c_block_data Methode, welche bestimmt, wie viele Zeiten es gibt eine Wiederholung starten, bevor es Probleme aufhören?
Der wiederholte start ausgegeben wird, nachdem der Master übermittelt hat, seine Daten an den slave (slave-in den receiver-Modus), um zum Lesen von Daten von den slave (slave im transmitter-Modus). Der wiederholte start wird verwendet, um vermeiden, einem anderen master auf dem bus die Kontrolle über den bus zu früh. Der Master fordert Daten so lange, wie es nicht ein Problem Stop-Bedingung oder der Slave nicht signal ein Nicht Bestätigen nach dem vorherigen übertragenen Byte.

InformationsquelleAutor a.Dippel

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.