Beschleunigungssensor MPU6050

[PhlppSchlz]

Ich habe eine Frage zu folgendem Code. Er funktioniert aber ich bekomme in Z-skaliert immer 1,2 G dabei müsste es doch 1,00001 G in Ruhelage sein.
Muss ich die Konfiguration des Sensors ändern?

Code: Alles auswählen

#!/usr/bin/python
import smbus
import math


try:    
    from tkinter import *
    import tkinter as tk
except ImportError:
    from Tkinter import *
    import Tkinter as tk

fenster = Tk() 
fenster.title("Beschleunigungssensor")
fenster.geometry("400x200")

running = True

save = open('Daten.txt','a')

def stop():
    global running
    running = False
    
def reset():
    global running
    running = True    
    lab4.config(text="-")
    lab5.config(text="-")
    lab6.config(text="-")
    lab7.config(text="-")
    


def Auslesen():


            #Register
    if running:
    
            power_mgmt_1 = 0x6b
            power_mgmt_2 = 0x6c
             
            def read_byte(reg):
                return bus.read_byte_data(address, reg)
             
            def read_word(reg):
                h = bus.read_byte_data(address, reg)
                l = bus.read_byte_data(address, reg+1)
                value = (h << 8) + l
                return value
             
            def read_word_2c(reg):
                val = read_word(reg)
                if (val >= 0x8000):
                    return -((65535 - val) + 1)
                else:
                    return val
             
            def dist(a,b):
                return math.sqrt((a*a)+(b*b))
             
            def get_y_rotation(x,y,z):
                radians = math.atan2(x, dist(y,z))
                return -math.degrees(radians)
             
            def get_x_rotation(x,y,z):
                radians = math.atan2(y, dist(x,z))
                return math.degrees(radians)
             
            bus = smbus.SMBus(1) # bus = smbus.SMBus(0) fuer Revision 1
            address = 0x68       # via i2cdetect


             
            #Aktivieren, um das Modul ansprechen zu koennen
            bus.write_byte_data(address, power_mgmt_1, 0)
             
            print ("Gyroskop")
            print ("--------")
             
            gyroskop_xout = read_word_2c(0x43)
            gyroskop_yout = read_word_2c(0x45)
            gyroskop_zout = read_word_2c(0x47)
             
            print ("gyroskop_xout: "), (("%5d") % gyroskop_xout), (" skaliert: "), (gyroskop_xout / 131)
            print ("gyroskop_yout: "), (("%5d") % gyroskop_yout), (" skaliert: "), (gyroskop_yout / 131)
            print ("gyroskop_zout: "), (("%5d") % gyroskop_zout), (" skaliert: "), (gyroskop_zout / 131)
                 
            print
            print ("Beschleunigungssensor")
            print ("---------------------")
         
            beschleunigung_xout = read_word_2c(0x3b)
            beschleunigung_yout = read_word_2c(0x3d)
            beschleunigung_zout = read_word_2c(0x3f)
                 
            beschleunigung_xout_skaliert = abs(beschleunigung_xout) / 16384.0
            beschleunigung_yout_skaliert = abs(beschleunigung_yout) / 16384.0
            beschleunigung_zout_skaliert = abs(beschleunigung_zout) / 16384.0
                 
            print ("beschleunigung_xout: "), (("%6d") % beschleunigung_xout), (" skaliert: "), beschleunigung_xout_skaliert
            print ("beschleunigung_yout: "), (("%6d") % beschleunigung_yout), (" skaliert: "), beschleunigung_yout_skaliert
            print ("beschleunigung_zout: "), (("%6d") % beschleunigung_zout), (" skaliert: "), beschleunigung_zout_skaliert
                 
            print ("X Rotation: ") , get_x_rotation(beschleunigung_xout_skaliert, beschleunigung_yout_skaliert, beschleunigung_zout_skaliert)
            print ("Y Rotation: ") , get_y_rotation(beschleunigung_xout_skaliert, beschleunigung_yout_skaliert, beschleunigung_zout_skaliert)
           
            
            lab4.config(text=str(beschleunigung_xout_skaliert))
            lab5.config(text=str(beschleunigung_yout_skaliert))
            lab6.config(text=str(beschleunigung_zout_skaliert))
            ausschlag =float(abs(beschleunigung_xout_skaliert))+(abs(beschleunigung_yout_skaliert))+(abs(beschleunigung_zout_skaliert-1.2))
            lab7.config(text=ausschlag)
            
            
            save.write('\n')
            save.write(str(ausschlag))
            
            
            knopf1.after(100, Auslesen) 
    
            
            
            
        


lab1=tk.Label(master=fenster, text="Beschleunigung X:")
lab1.grid(row=0, column=0, padx=25)
lab2=tk.Label(master=fenster, text="Beschleunigung Y:")
lab2.grid(row=1, column=0)
lab3=tk.Label(master=fenster, text="Beschleunigung Z:")
lab3.grid(row=2, column=0)
lab4=tk.Label(master=fenster, text="-")
lab4.grid(row=0, column=1)
lab5=tk.Label(master=fenster, text="-")
lab5.grid(row=1, column=1)
lab6=tk.Label(master=fenster, text="-")
lab6.grid(row=2, column=1)
lab7=tk.Label(master=fenster, text="-")
lab7.grid(row=3, column=1)
lab8=tk.Label(master=fenster, text="Ausschlag:")
lab8.grid(row=3, column=0)


knopf1 = Button(fenster, text="Start", command=Auslesen)
knopf1.grid(row=4, column=0)

knopf2 = Button(fenster, text="Stop!", command=stop) 
knopf2.grid(row=5, column=0)

knopf3 = Button(fenster, text="Reset", command=reset) 
knopf3.grid(row=6, column=0)

knopf3 = Button(fenster, text="Schließen", command=fenster.destroy) 
knopf3.grid(row=6, column=1)


mainloop()

[__deets__]

Statt die Bytes immer einzeln zu lesen, solltest du die 12 immer in einem Rutsch einlesen, und dann mit dem struct-Modul gleich richtig als "shorts" dekodieren.

Jenseits davon: die offensichtliche Fehlerquelle waere die Wandlung vom 16 bit-Wert in ein Float. Ich habe keine Lust jetzt das Datenblatt zu waelzen, aber der Faktor muss natuerlich stimmen. Das wuerde ich zuerst pruefen. Dann kannst du mal schauen, ob die anderen Achsen das gleiche Problem zeigen, wenn du auf die kippst. Oder ob das nur die Z-Achse ist. Last but not least: die Dinger sind billige Massenware, es lohnt sich mal ein anderes auszuprobieren. Und dann lohnt es sich natuerlich immer, in anderer Leute Code zu schauen. Dafuer gibt es ja ausreichend, du kannst zB mal das Betaflight github repository nach C-Code fuer die MPU6050 durchsuchen - das ist Software fuer Kopter, und die brauchen das ja auch.

[DeaD_EyE]

Einfach mal dieses Modul testen: https://pypi.org/project/mpu6050-raspberrypi/

Hier ist die Methode get_accel_data zu finden: https://github.com/m-rtijn/mpu6050/blob ... 50.py#L132
Für die Beschleunigung gibt es einen Faktor, der abhängig vom gesetzten Bereich ist. Wenn du also den falschen Faktor verwendest, bekommst du auch die falschen Werte.

Der Autor hält sich nicht an PEP8, also nicht zu sehr danach richten.

[PhlppSchlz]

Danke euch aber __deets__ hatte Recht der Sensor hat nur auf z diesen Fehler mit einem neuen Sensor hats super geklappt. Manchmal liegt es zu nah als, dass man selber drauf kommt den Sensor zu tauschen