Пример #1
0
def sensor_data_acc():
    i2c = busio.I2C(board.SCL, board.SDA)
    accl_sensor = LSM6DSOX(i2c)
    while True:
        x = accl_sensor.acceleration[0]
        y = accl_sensor.acceleration[1]
        z = accl_sensor.acceleration[2]
        acc = math.sqrt(x*x + y*y + z*z)
        sio.emit('my_message',{'acc':acc})
        if acc > 20:
            GPIO.setmode(GPIO.BCM)
            GPIO.setwarnings(False)
            GPIO.setup(18,GPIO.OUT)
            GPIO.output(18,GPIO.HIGH)
            time.sleep(2)
            GPIO.output(18,GPIO.LOW)
        sio.sleep(1)
Пример #2
0
    def __init__(self, i2c=None):
        super().__init__('rtf_lsm6sox')
        # Base.__init__(self, 70)

        self.timer_imu = self.create_timer(1 / 100, self.callback)

        if i2c is None:
            self.i2c = busio.I2C(board.SCL, board.SDA, frequency=400000)
        else:
            self.i2c = i2c

        # 'RANGE_1000_DPS', 'RANGE_125_DPS', 'RANGE_2000_DPS', 'RANGE_250_DPS', 'RANGE_4000_DPS', 'RANGE_500_DPS'
        self.imu = LSM6DSOX(self.i2c)
        self.imu.accelerometer_range = AccelRange.RANGE_4G  # pylint: disable=no-member
        self.imu.accelerometer_data_rate = Rate.RATE_104_HZ
        self.imu.gyro_range = GyroRange.RANGE_2000_DPS
        self.imu.gyro_data_rate = Rate.RATE_104_HZ

        frame_id = self.declare_parameter('frame_id', "base_imu_link").value
        self.accels_bias = self.declare_parameter('accels_bias', [0., 0., 0.])
        self.gyros_bias = self.declare_parameter('gyros_bias', [0., 0., 0.])

        self.pub_imu = self.create_publisher(Imu, 'imu', 10)

        self.imu_msg = Imu()
        self.imu_msg.header.frame_id = frame_id

        ac, oc, vc = (0.01, 0.001, 0.01)
        self.imu_msg.linear_acceleration_covariance = [
            ac, 0.0, 0.0, 0.0, ac, 0.0, 0.0, 0.0, ac
        ]
        self.imu_msg.orientation_covariance = [
            oc, 0.0, 0.0, 0.0, oc, 0.0, 0.0, 0.0, oc
        ]
        self.imu_msg.angular_velocity_covariance = [
            vc, 0.0, 0.0, 0.0, vc, 0.0, 0.0, 0.0, vc
        ]

        self.calibrate = False
def main():

    rospy.init_node('accelerometer', anonymous=False)
    pub = rospy.Publisher("imu", Imu, queue_size=10)

    
    print(board.SCL, board.SDA)
    i2c = busio.I2C(board.SCL, board.SDA)
    sensor = LSM6DSOX(i2c)

    rospy.loginfo('ISM330DHCX 6DOF Accelerometer Publishing to IMU')

    imu_msg = Imu()
    
    imu_msg.linear_acceleration_covariance = [
        0, 0, 0, 
        0, 0, 0, 
        0, 0, 0 
    ]
    imu_msg.angular_velocity_covariance = [
        0, 0, 0, 
        0, 0, 0, 
        0, 0, 0 
    ]
    while not rospy.is_shutdown():
        x, y, z = sensor.acceleration
        u,v,w = sensor.gyro
        imu_msg.angular_velocity.x = u
        imu_msg.angular_velocity.y = v
        imu_msg.angular_velocity.z = w
        imu_msg.linear_acceleration.x = x
        imu_msg.linear_acceleration.y = y
        imu_msg.linear_acceleration.z = z
        pub.publish(imu_msg)
        rospy.sleep(1)

    rospy.loginfo('ISM330DHCX Accelerometer Offline')
# SPDX-FileCopyrightText: Copyright (c) 2020 Bryan Siepert for Adafruit Industries
#
# SPDX-License-Identifier: MIT
import time
import board
from adafruit_lsm6ds.lsm6dsox import LSM6DSOX

i2c = board.I2C()  # uses board.SCL and board.SDA
sensor = LSM6DSOX(i2c)

while True:
    print("Acceleration: X:%.2f, Y: %.2f, Z: %.2f m/s^2" % (sensor.acceleration))
    print("Gyro X:%.2f, Y: %.2f, Z: %.2f radians/s" % (sensor.gyro))
    print("")
    time.sleep(0.5)
#-----------------------------------------------------------------------------------------------------
#Program will simply display RTC Temperature and initialize RTC time to zero.
#-----------------------------------------------------------------------------------------------------
#Acceleration/Gyro Sensor : adafruit LSM6DSOX
#RTC Module : adafruit DS3231
#-----------------------------------------------------------------------------------------------------
#Coded by : Nicholas P. Shay, Mechanical Engineering 2022, [email protected]
#Date : 12/5/2020
#-----------------------------------------------------------------------------------------------------
import time  #Library for debugging and buffering
import csv  #Library to write data into csv file
import board  #Library for CircuitPi to get board info
import busio  #Library for CircuitPi bus communication
from adafruit_lsm6ds.lsm6dsox import LSM6DSOX  #Library for CircuitPi accel/gyrosensor
import adafruit_ds3231  #Library for CircuitPi RTC

i2c = busio.I2C(board.SCL,
                board.SDA)  #Define i2c connection with circuitPi busio
sox = LSM6DSOX(i2c)  #Define acceleration sensor for data
ds3231 = adafruit_ds3231.DS3231(i2c)  #Define RTC module for timing

for i in range(1, 10):
    t_RTC = ds3231.temperature
    print(t_RTC)
    time.sleep(1)
t = time.struct_time(
    (2020, 12, 12, 00, 00, 00, 0, -1,
     -1))  #Set RTC Clock to 0 hr/min/s before starting data collection
ds3231.datetime = t
print("Success, time is:", t)  #Used for debugging RTC clockset
print()  #Used for debugging RTC clockset
Пример #6
0
offset = 20

led = neopixel.NeoPixel(board.D9,numled,auto_write = False, pixel_order = neopixel.GRBW)

#Led colors
maxbright = 30
red = (maxbright,0,0,0)
orange = (maxbright, maxbright/2.8,0,0)
green = (0,maxbright,0,0)
blue = (0,0,maxbright,0)
white = (0,0,0,maxbright)
off = (0,0,0,0)

#initate IMU
i2c = busio.I2C(board.SCL, board.SDA)
imu = LSM6DSOX(i2c)
#LSM6DSOX._set_gyro_range(imu, )
imu.gyro_range = 2
imu.accelerometer_range = 2
imu.accelerometer_data_rate = 8
imu.gyro_data_rate = 8
#set adresses
temp = 0
for a in range(0,numled):
    ledarray[temp] = a 
    temp = temp+3

#set theta around the y axis
temp = 1
for b in range(0,12):
    w = rings[b]
Пример #7
0
import time
import board
import busio
from adafruit_lsm6ds.lsm6dsox import LSM6DSOX

i2c = busio.I2C(board.SCL, board.SDA)
sox = LSM6DSOX(i2c)

while True:
    print("Acceleration: X:%.2f, Y:%.2f, Z:%.2f m/s^2" % (sox.acceleration))
    #print("Gryo: x:%.2f, y:%.2f, z:%.2f degrees/s" % (sox.gyro))
    print("")
    time.sleep(0.5)