예제 #1
0
class SenseHatThing(Thing):
    """A Thing which updates its measurement every few seconds."""
    def __init__(self):
        Thing.__init__(self, 'urn:dev:ops:my-sense-hat-1234', 'My Sense Hat',
                       ['MultiLevelSensor'], 'A web connected sense hat')
        self.sense = SenseHat()
        self.sense.set_imu_config(False, True, False)
        self.compass = Value(0.0)
        self.add_property(
            Property(self,
                     'compass',
                     self.compass,
                     metadata={
                         'title': 'Compass',
                         'type': 'number',
                         'description': 'Angle to North',
                         'unit': 'º',
                         'minimum': 0,
                         'maximum': 360,
                         'readOnly': True,
                     }))

        logging.debug('starting the sensor update looping task')
        self.timer = tornado.ioloop.PeriodicCallback(self.update_properties,
                                                     1000)
        self.timer.start()

    def update_properties(self):
        compass = self.sense.get_compass()
        logging.debug("update: compass=%s", compass)
        self.compass.notify_of_external_update(compass)

    def cancel_update_properties_task(self):
        self.timer.stop()
예제 #2
0
def SenseHatData(conf, dataobj):
    sense = SenseHat()
    sense.clear()
    zero_pressure = sense.get_pressure()
    while not conf.shutdown:
        # Adjust ground pressure in case of anomaly
        if conf.state == "HALT":
            zero_pressure = zero_pressure * .9 + sense.get_pressure() * .1

        # Altimeter
        data = dataobj.current_data
        current_pressure = sense.get_pressure()
        data["sensors"]["alt"] = get_altitude(
            zero_pressure, sense.get_pressure(),
            sense.get_temperature())  # meters
        data["sensors"]["hum"] = sense.get_humidity()  # %
        data["sensors"]["temp"] = (sense.get_temperature() * 9 / 5) + 32  # F
        data["sensors"]["pres"] = current_pressure
        conf.data.add_dp(current_pressure - conf.data.last_pressure)
        conf.data.last_pressure = current_pressure

        # IMU
        data["sensors"]["acc"] = sense.get_accelerometer_raw()  # Gs
        data["sensors"]["pitch"] = sense.get_accelerometer()[
            "pitch"]  # degrees
        data["sensors"]["yaw"] = sense.get_accelerometer()["yaw"]  # degrees
        data["sensors"]["roll"] = sense.get_accelerometer()["roll"]  # degrees
        data["sensors"]["compass"] = sense.get_compass()  # rad/sec
        data["sensors"]["gyro"] = sense.get_gyroscope_raw()  # rad/sec
        data["sensors"]["mag"] = sense.get_compass_raw()  # microteslas
예제 #3
0
class AlarmSensor(object):
    def __init__(self):
        '''
        Constructor : Initializing Compass Sensor and Sensehat
        and setting ubidots variables and topic's values
        
        '''
        self.sensehat = SenseHat()
        self.waitInSec = 1
        self.red = (255, 0, 0)
        self.CompassSensorData = "Compass Sensor"
        self.ubidots_Compass_Var = "/compasssensor"  #ubidots device variable
        self.ubidots_alert_actuator = '/alert'  #ubidots actuator variable
        self.ubidots_device = "/sos"  #ubidots device name
        self.ubidots_compass_topic = "/v1.6/devices" + self.ubidots_device + self.ubidots_Compass_Var
        self.alert_topic = "/v1.6/devices" + self.ubidots_device + self.ubidots_alert_actuator
        self.mqttClient = MqttClientConnectorNew.MqttClientConnectorNew()
        self.motion = 0
        self.setangle = 0
        self.http = HTTPCompassPublisher.HTTPCompassPublisher()

    '''Enabling the emulator
      @param enableEmulator:  Defaults to false; if true will enable emulator to run
    '''

    def setEnableEmulatorFlag(self, enableEmulator):
        self.enableEmulator = enableEmulator

    '''Running compass sensor
    '''

    def run(self):
        while True:
            if self.enableEmulator:
                '''accepting  compass value from SenseHat by setting IMU config,
                       converting it to a fix value to avoid the lag 
                       and sending it to httpCompasspublisher to send over cloud
                    '''
                self.sensehat.set_imu_config(True, False, False)
                while True:
                    self.motion = self.sensehat.get_compass()
                    print("actual  %s" % self.motion)
                    '''normal angle =200 and alert angle=150'''
                    if self.motion > 250 or self.motion < 80:
                        self.setangle = 150
                        print("alert angle %s" % self.setangle)
                    else:
                        self.setangle = 200
                        print(" normal angle %s" % self.setangle)
                    self.http.post(self.setangle)  # posting data to cloud
                    sleep(0.5)

    '''defining thread and its parameter.
    the thread will execute run function
    '''

    def start(self):  #
        t = threading.Thread(target=self.run())
        t.start()
예제 #4
0
class SensePublisher:
    def __init__(self):
        self.sense = SenseHat()
        self.sense.clear()
        self.pub_humidity = rospy.Publisher('sensehat/humidity',
                                            Float64,
                                            queue_size=10)
        self.pub_temperature = rospy.Publisher('sensehat/temperature',
                                               Float64,
                                               queue_size=10)
        self.pub_pressure = rospy.Publisher('sensehat/pressure',
                                            Float64,
                                            queue_size=10)
        self.pub_accelerometer = rospy.Publisher('sensehat/accelerometer',
                                                 Vector3,
                                                 queue_size=10)
        self.pub_gyroscope = rospy.Publisher('sensehat/gyroscope',
                                             Vector3,
                                             queue_size=10)
        self.pub_magnetometer = rospy.Publisher('sensehat/magnetometer',
                                                Vector3,
                                                queue_size=10)
        self.pub_compass = rospy.Publisher('sensehat/compass',
                                           Float64,
                                           queue_size=10)
        self.pub_stick = rospy.Publisher('sensehat/stick',
                                         SenseInputEvent,
                                         queue_size=10)

    def publish(self):
        self.pub_humidity.publish(self.sense.get_humidity())
        self.pub_temperature.publish(self.sense.get_temperature())
        self.pub_pressure.publish(self.sense.get_pressure())
        acceleration = self.sense.get_accelerometer_raw()
        self.pub_accelerometer.publish(
            Vector3(acceleration['x'], acceleration['y'], acceleration['z']))
        gyroscope = self.sense.get_gyroscope_raw()
        self.pub_gyroscope.publish(
            Vector3(gyroscope['x'], gyroscope['y'], gyroscope['z']))
        compass = self.sense.get_compass_raw()
        self.pub_magnetometer.publish(
            Vector3(compass['x'], compass['y'], compass['z']))
        self.pub_compass.publish(self.sense.get_compass())
        stickEvents = self.sense.stick.get_events()
        if len(stickEvents) > 0:
            event = SenseInputEvent(stickEvents[-1].direction,
                                    stickEvents[-1].action)
            self.pub_stick.publish(event)

    def turn_off(self):
        self.sense.clear()

    def run(self):
        rospy.init_node('sense_hat', anonymous=True)
        rate = rospy.Rate(10)  # 10hz
        while not rospy.is_shutdown():
            self.publish()
            rate.sleep()
예제 #5
0
 def _init_(self):
         device_sensor = SenseHat()
         self.device_id = 4
         self.device_lon = random.uniform(-76.8, -77.2)
         self.device_lat = random.uniform(38.75, 39.0)
         self.device_last_time = time.time()
         self.device_last_temp = device_sensor.get_gyroscope()
         self.device_last_humidity = device_sensor.get_accelerometer()
         self.device_last_mag = device_sensor.get_compass()
         self.device_last_pressure = device_sensor.get_pressure()
         return self
예제 #6
0
def get_direction():
    sense = SenseHat()
    heading = sense.get_compass()

    if heading < 45 or heading >= 315:
        return 'N'
    elif heading < 135:
        return 'E'
    elif heading < 225:
        return 'S'
    else:
        return 'W'
예제 #7
0
파일: app1.py 프로젝트: rtibell/sens1
def root():
    sense = SenseHat()
    temp1 = sense.get_temperature()
    temp2 = sense.get_temperature_from_pressure()
    pressure = sense.get_pressure()
    north = sense.get_compass()
    accel_only = sense.get_accelerometer()
    acc_raw = sense.get_accelerometer_raw()
    temp = "Temp {:10.4f}".format(temp1) + " {:10.4f}".format(temp2)
    other = "Pres {:10.4f}".format(pressure) + " Compas {:10.4f}".format(north)
    acc1 = "p: {pitch}, r: {roll}, y: {yaw}".format(**accel_only)
    acc2 = "x: {x}, y: {x}, z: {z}".format(**acc_raw)
    print temp + "\n" + other + "\n" + acc1 + "\n" + acc2 + "\n"
예제 #8
0
 def _init_(self):
     device_sensor = SenseHat()
     self.device_id = 1
     self.device_lon = random.uniform(-76.8, -77.2)
     self.device_lat = random.uniform(38.75, 39.0)
     self.device_last_time = time.time()
     self.device_last_temp = device_sensor.get_temperature()
     self.device_last_humidity = device_sensor.get_humidity()
     self.device_last_mag = device_sensor.get_compass()
     self.device_last_pressure = device_sensor.get_pressure()
     self.device_last_wind_speed = random.uniform(0.0, 20)
     self.device_last_rain_guage = random.uniform(0.0, 10)
     return self
예제 #9
0
파일: app1.py 프로젝트: rtibell/sens1
def root():
    sense = SenseHat()
    temp1 = sense.get_temperature()   
    temp2 = sense.get_temperature_from_pressure() 
    pressure = sense.get_pressure()
    north = sense.get_compass()
    accel_only = sense.get_accelerometer()
    acc_raw = sense.get_accelerometer_raw()
    temp = "Temp {:10.4f}".format(temp1) + " {:10.4f}".format(temp2) 
    other = "Pres {:10.4f}".format(pressure) + " Compas {:10.4f}".format(north)
    acc1 = "p: {pitch}, r: {roll}, y: {yaw}".format(**accel_only)
    acc2 = "x: {x}, y: {x}, z: {z}".format(**acc_raw)
    print temp + "\n" + other + "\n" + acc1 + "\n" + acc2 + "\n"
예제 #10
0
    def show(self):
        sense_hat = SenseHat()

        degrees_from_north = sense_hat.get_compass()

        direction = self.Direction.N

        for direction, range in self.direction_ranges.items():
            if self.isWithinRange(degrees_from_north, range):
                direction = direction
                break

        degrees_180 = degrees_from_north if degrees_from_north <= 180 else degrees_from_north - 360
        # print(degrees_from_north, direction.name, self.direction_colors[direction])
        sense_hat.show_message("{} {:.1f}".format(direction.name, degrees_180),
                               text_colour=self.direction_colors[direction])
예제 #11
0
def sensehat(sensor):
    from sense_hat import SenseHat
    sense = SenseHat()

    if (sensor == "mv_sensors"):
        while True:
            if (magnetometer == True):
                sense.set_imu_config(True, False, False)
                north = sense.get_compass()
                print("direction {0:.1f}".format(north))
            if (gyroscope == True):
                sense.set_imu_config(False, True, False)
                gyro_only = sense.get_gyroscope()
                print("pitch: {pitch}".format(**sense.gyro))
                print("yaw: {yaw}".format(**sense.gyro))
                print("roll: {roll}".format(**sense.gyro))
            if (accelerometer == True):
                sense.set_imu_config(False, False, True)
                raw = sense.get_accelerometer_raw()
                print("ac_x: {x}".format(**raw))
                print("ac_y: {y}".format(**raw))
                print("ac_z: {z}".format(**raw))

    elif (sensor == "temperature"):
        for x in range(0, 3):
            t1 = sense.get_temperature_from_humidity()
            t2 = sense.get_temperature_from_pressure()
            t = (t1 + t2) / 2
            t_cpu = get_cpu_temp()
            # calculates the real temperature compesating CPU heating
            t_corr = t - ((t_cpu - t) / 1.6)
            t_corr = get_smooth(t_corr)
            mesurement = t_corr
    elif (sensor == "humidity"):
        #Approximating from Buck's formula Ha = Hm*(2.5-0.029*Tm)
        temp = sense.get_temperature()
        humidity = sense.get_humidity()
        calchum = humidity * (2.5 - 0.029 * temp)
        mesurement = calchum
    elif (sensor == "pressure"):
        mesurement = sense.get_pressure()
    return mesurement
예제 #12
0
class IMU:
    def __init__(self):
        self.sense = SenseHat()
        self.sense.clear()
        self.zero_pressure = self.sense.get_pressure()

    def get_accelerometer():
        return self.sense.get_accelerometer()

    def get_compass():
        return self.sense.get_compass()

    def get_accerometer_raw():
        return self.sense.get_accelerometer_raw()

    def get_gyroscope_raw():
        return self.sense.get_gyroscope_raw()

    def get_compass_raw():
        return self.sense.get_compass_raw()
예제 #13
0
def publishOtherInfo():
    sense = SenseHat()
    while True:
        try:
            # get temperature data
            temp = sense.get_temperature()
            temp = round(temp, 1)
            publish('temperature', {'temperature': temp})
            print('Temperature: ' + str(temp) + '; ')

            # get humidity data
            hum = sense.get_humidity()
            hum = round(hum, 1)
            publish('humidity', {'humidity': hum})
            print('Humidity: ' + str(hum) + '; ')

            # get pressure data
            pre = sense.get_pressure()
            pre = round(pre, 1)
            publish('pressure', {'pressure': pre})
            print('Pressure: ' + str(pre))

            # get compass data
            compass_north = sense.get_compass()
            compass_north = round(compass_north, 1)
            compass_data = sense.get_compass_raw()
            m_x = compass_data['x']
            m_x = round(m_x, 1)
            m_y = compass_data['y']
            m_y = round(m_y, 1)
            m_z = compass_data['z']
            m_z = round(m_z, 1)
            publish('compass', {'north':compass_north,'m_x': m_x, 'm_y': m_y, 'm_z': m_z})
            print('North: ' + str(compass_north) + ' Compass_x: ' + str(m_x) + ' Compass_y: ' + str(m_y) + ' Compass_z: ' + str(m_z) + '\n')

            time.sleep(3)

        except IOError:
            print("IOError")
예제 #14
0
def runCompass():

	led_loop = [4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8, 0, 1, 2, 3]

	sense = SenseHat()
	sense.set_rotation(0)
	sense.clear()

	prev_x = 0
	prev_y = 0

	led_degree_ratio = len(led_loop) / 360.0

        elapsed = time.time()
        futureTime = time.time() + 60 

        #run the compass for 1 minute
	while elapsed < futureTime:
                elapsed = time.time()
    		try:
    			dir = sense.get_compass()
    			dir_inverted = 360 - dir  # So LED appears to follow North
    			led_index = int(led_degree_ratio * dir_inverted)
    			offset = led_loop[led_index]

		    	y = offset // 8  # row
		    	x = offset % 8  # column

    			if x != prev_x or y != prev_y:
        			sense.set_pixel(prev_x, prev_y, 0, 0, 0)

		    	sense.set_pixel(x, y, 0, 0, 255)

		    	prev_x = x
		    	prev_y = y
	        except (KeyboardInterrupt):
		    	sense.clear()
		        sys.exit(0)
	sense.clear()
예제 #15
0
def main():
    # Query pisense
    sense = SenseHat()
    # Temperature
    t = sense.get_temperature()
    cpu_temp = str((str(subprocess.check_output("vcgencmd measure_temp", shell=True)).replace("temp=","")).replace("'C",""))
    cpu_temp = float(re.findall("\d+\.\d+", cpu_temp)[0])
    t_c = t - ((cpu_temp - t)/1.166) # calibrate according to CPU temp
    t_c = round(((t_c/5.0)*9)+32,1) #farenheit
    # Compass
    compass = sense.get_compass()
    # Humidity
    h = sense.get_humidity()
    h = round(h, 1)
    # Barometric Pressure
    p = round(sense.get_pressure(),2)
    msg = "Euplotid says: Temp = {0}'F, Press = {1}Pa, Humidity = {2}%".format(t_c,p,h)
    sense.show_message(msg, scroll_speed=0.02)
    
    #create and save entry in DB
    pisense_dbrow = piSenseRead(datetime.datetime.now(), p, t_c, h)
    db.session.add(pisense_dbrow)
    db.session.commit()
    sense.clear()
예제 #16
0
# Configure CSV
csvfile = util.path_for_data(1)
logger.info(f'Logging to {csvfile}')
# TODO write header

while True:
    # Check for end time
    now = datetime.now()
    if now >= end_time:
        logger.info(f'Finished run at {now}')
        break

    # Main loop
    try:
        orientation = sh.get_orientation_degrees()
        compass = sh.get_compass()
        compass_raw = sh.get_compass_raw()
        gyro = sh.get_gyroscope()
        gyro_raw = sh.get_gyroscope_raw()
        accelerometer_raw = sh.get_accelerometer_raw()
        camera.capture(debug_capture=True)

        util.add_csv_data(csvfile, (
            now,
            sh.get_humidity(),
            sh.get_temperature(),
            sh.get_temperature_from_humidity(),
            sh.get_temperature_from_pressure(),
            sh.get_pressure(),
            orientation['roll'],
            orientation['pitch'],
예제 #17
0
O, O, O, O, O, O, O, O,
O, X, X, O, O, X, X, O,
O, X, X, O, O, X, X, O,
O, O, O, O, O, O, O, O,
O, O, O, O, O, O, O, O,
O, X, O, O, O, O, X, O,
O, O, X, X, X, X, O, O,
O, O, O, X, X, O, O, O
]


while (1 == 1) :
    print("%s Temperature" % sense.temp)
    print("%s Temp - humidity sensor" % sense.get_temperature_from_humidity())
    print("%s Temp - pressure sensor" % sense.get_temperature_from_pressure())
    print("%s Pressure: in Millibars" % sense.get_pressure())
    print("%s Humidity" % sense.get_humidity())

    north = sense.get_compass()
    print("%s Degrees to north" % north)

    raw = sense.get_accelerometer_raw()
    print("Acc intensity in Gs x: {x}, y: {y}, z: {z}".format(**raw))

    m = '%.1f' % sense.temp
    sense.show_message(m, text_colour=[255, 0, 0])
    print("*********")
    sense.set_pixels(question_mark)
    time.sleep(1)
    
예제 #18
0
 def update_mag(self):
     device_sensor = SenseHat()
     self.device_last_mag = device_sensor.get_compass()
     self.device_last_time = time.time()
예제 #19
0
class PiSenseHat(object):
    """Raspberry Pi 'IoT Sense Hat API Driver Class'."""

    # Constructor
    def __init__(self):
        self.sense = SenseHat()
        # enable all IMU functions
        self.sense.set_imu_config(True, True, True)

    # pixel display
    def set_pixel(self, x, y, color):
        # red = (255, 0, 0)
        # green = (0, 255, 0)
        # blue = (0, 0, 255)
        self.sense.set_pixel(x, y, color)

    # clear pixel display
    def clear_display(self):
        self.sense.clear()

    # Pressure
    def getPressure(self):
        return self.sense.get_pressure()

    # Temperature
    def getTemperature(self):
        return self.sense.get_temperature()

    # Humidity
    def getHumidity(self):
        return self.sense.get_humidity()

    def getHumidityTemperature(self):
        return self.sense.get_temperature_from_humidity()

    def getPressureTemperature(self):
        return self.sense.get_temperature_from_pressure()

    def getOrientationRadians(self):
        return self.sense.get_orientation_radians()

    def getOrientationDegrees(self):
        return self.sense.get_orientation_degrees()

    # degrees from North
    def getCompass(self):
        return self.sense.get_compass()

    def getAccelerometer(self):
        return self.sense.get_accelerometer_raw()

    def getEnvironmental(self):
        sensors = {'name': 'sense-hat', 'environmental': {}}
        return sensors

    def getJoystick(self):
        sensors = {'name': 'sense-hat', 'joystick': {}}
        return sensors

    def getInertial(self):
        sensors = {'name': 'sense-hat', 'inertial': {}}

    def getAllSensors(self):
        sensors = {
            'name': 'sense-hat',
            'environmental': {},
            'inertial': {},
            'joystick': {},
            'location': {}
        }  # add location
        sensors['environmental']['pressure'] = {
            'value': self.sense.get_pressure(),
            'unit': 'mbar'
        }
        sensors['environmental']['temperature'] = {
            'value': self.sense.get_temperature(),
            'unit': 'C'
        }
        sensors['environmental']['humidity'] = {
            'value': self.sense.get_humidity(),
            'unit': '%RH'
        }
        accel = self.sense.get_accelerometer_raw()
        sensors['inertial']['accelerometer'] = {
            'x': accel['x'],
            'y': accel['y'],
            'z': accel['z'],
            'unit': 'g'
        }
        orientation = self.sense.get_orientation_degrees()
        sensors['inertial']['orientation'] = {
            'compass': self.sense.get_compass(),
            'pitch': orientation['pitch'],
            'roll': orientation['roll'],
            'yaw': orientation['yaw'],
            'unit': 'degrees'
        }

        sensors['location']['lat'] = {
            'value': 0
        }  # initialize these with 0 values to start
        sensors['location']['lon'] = {'value': 0}
        sensors['location']['alt'] = {'value': 0}
        sensors['location']['sats'] = {'value': 0}
        sensors['location']['speed'] = {'value': 0}

        return sensors
예제 #20
0
    e,
    y,
    y,
    e,
    e,
    e,
]

# Send magnetometer and sensors information every second and 50 times
count = 0

while (count < 50):
    # Publish Sensor info
    mqttc.publish(MQTT_TOPIC1, MQTT_MSG1, qos=1)
    # Magnetometer actions
    north = sense.get_compass()  # Get compass data
    MQTT_MSG3 = "North: {0:.0f} Degree".format(north)
    mqttc.publish(MQTT_TOPIC3, MQTT_MSG3, qos=1)
    # Joystick action - show the direction on the display
    for event in sense.stick.get_events():
        MQTT_MSG2 = "The joystick was moving {}".format(event.direction)
        if event.direction == 'left':
            sense.set_pixels(left)
            time.sleep(1)
            sense.clear()
        elif event.direction == 'right':
            sense.set_pixels(right)
            time.sleep(1)
            sense.clear()
        elif event.direction == 'up':
            sense.set_pixels(up)
예제 #21
0
파일: compass.py 프로젝트: fvdbosch/PiIoT
#!/usr/bin/env python
# -*- coding: utf-8 -*-

from sense_hat import SenseHat
from time import sleep

sh = SenseHat()

try:
    while True:
        north = sh.get_compass()
        north = round( north, 1 )

        print( "North = %s°" %(north) )

except KeyboardInterrupt:
    print( "Exiting..." );
예제 #22
0
# Python SenseHat API documentation:
# https://pythonhosted.org/sense-hat/api

# Roll is: angular x.
# Pitch is: angular y.
# Yaw is: angular z.

data_imu = {}
data_imu["gyro"] = sense.get_orientation_degrees(
)  # Gets orientation (3-ang-axis) in [deg].
data_imu["acc"] = sense.get_accelerometer(
)  # Gets orientation from the accelerometer (3-ang-axis) in [deg].
data_imu["gyror"] = sense.get_gyroscope_raw(
)  # Gets angular velocity (3-axis) in [rad/s].
data_imu["mag"] = sense.get_compass()  # Gets orientation to North in [deg].
data_imu["magr"] = sense.get_compass_raw(
)  # Gets magnetic field (3-axis) in [µT].
data_imu["accr"] = sense.get_accelerometer_raw(
)  # Gets acceleration (3-axis) in [g]'s.

data_env = {}
data_env["temph"] = sense.get_temperature_from_humidity(
)  # Gets temperature from humidity sensor in [ºC].
data_env["tempp"] = sense.get_temperature_from_pressure(
)  # Gets temperature from pressure sensor in [ºC].
data_env["pres"] = sense.get_pressure()  # Gets pressure in [mbar].
data_env["hum"] = sense.get_humidity()  # Gets relative humidity in [%].
cpu_temp = os.popen("vcgencmd measure_temp").readline()
data_env["tempcpu"] = float(cpu_temp.replace("temp=", "").replace("'C\n", ""))
예제 #23
0
#!/usr/bin/python
import time
from sense_hat import SenseHat

sense = SenseHat()

while True:
    compass = sense.get_compass()
    print ("compass"), compass
    print
    time.sleep(0.1)
예제 #24
0
class PiSenseHat(object):
    """Raspberry Pi 'IoT Sense Hat API Driver Class'."""

    # Constructor
    def __init__(self):
        self.sense = SenseHat()
        # enable all IMU functions
        self.sense.set_imu_config(True, True, True)

    # pixel display
    def set_pixel(self,x,y,color):
    # red = (255, 0, 0)
    # green = (0, 255, 0)
    # blue = (0, 0, 255)
        self.sense.set_pixel(x, y, color)

    # clear pixel display
    def clear_display(self):
        self.sense.clear()
        
    # Pressure
    def getPressure(self):
        return self.sense.get_pressure()

    # Temperature
    def getTemperature(self):
        return self.sense.get_temperature()

    # Humidity
    def getHumidity(self):
        return self.sense.get_humidity()

    def getHumidityTemperature(self):
        return self.sense.get_temperature_from_humidity()

    def getPressureTemperature(self):
        return self.sense.get_temperature_from_pressure()

    def getOrientationRadians(self):
        return self.sense.get_orientation_radians()

    def getOrientationDegrees(self):
        return self.sense.get_orientation_degrees()

    # degrees from North
    def getCompass(self):
        return self.sense.get_compass()

    def getAccelerometer(self):
        return self.sense.get_accelerometer_raw()

    def getEnvironmental(self):
        sensors = {'name' : 'sense-hat', 'environmental':{}}
        return sensors

    def getJoystick(self):
        sensors = {'name' : 'sense-hat', 'joystick':{}}
        return sensors

    def getInertial(self):
        sensors = {'name' : 'sense-hat', 'inertial':{}}

    def getAllSensors(self):
        sensors = {'name' : 'sense-hat', 'environmental':{}, 'inertial':{}, 'joystick':{}}
        sensors['environmental']['pressure'] = { 'value':self.sense.get_pressure(), 'unit':'mbar'}
        sensors['environmental']['temperature'] = { 'value':self.sense.get_temperature(), 'unit':'C'}
        sensors['environmental']['humidity'] = { 'value':self.sense.get_humidity(), 'unit': '%RH'}
        accel = self.sense.get_accelerometer_raw()
        sensors['inertial']['accelerometer'] = { 'x':accel['x'], 'y':accel['y'], 'z': accel['z'], 'unit':'g'}
        orientation = self.sense.get_orientation_degrees()
        sensors['inertial']['orientation'] = { 'compass':self.sense.get_compass(), 'pitch':orientation['pitch'], 'roll':orientation['roll'], 'yaw': orientation['yaw'], 'unit':'degrees'}
        return sensors
예제 #25
0
class sensors():
    def __init__(self):
        self.pitch = 0
        self.roll = 0
        self.yaw = 0
        self.heading = 10
        self.temp = 0
        self.humidity = 0
        self.pressure = 0
        self.ax = 0
        self.ay = 0
        self.az = 0
        self.altitude = 0
        self.send_timer=0

    def joinDelimiter(self, arr):
        tmp=[None]*len(arr)
        for i in range(len(arr)):
            tmp[i]=str(arr[i])
        return ",".join(tmp)

    def getRandomStrArr(self):
        pitch = r.randint(3, 5)
        roll = r.randint(3, 5)
        yaw = r.randint(0, 2)
        compass = r.randint(240, 241)
        temp = r.randint(19, 20)
        humidity = r.randint(43, 46)
        pressure = r.randint(983, 985)
        ax = 0.1
        ay = 0.1
        az = 0.1
        altitude = 286
        return self.joinDelimiter([pitch, roll, yaw, compass, temp, humidity, pressure, ax, ay, az, altitude])

    def run(self):
        # Comment if not running on RPI
        self.sense = SenseHat()
        self.sense.clear()
        self.sense.set_imu_config(True, True, True)

        while True:
            self.temp = round(self.sense.get_temperature(), 1)
            self.humidity = round(self.sense.get_humidity(), 1)
            self.pressure = round(self.sense.get_pressure(), 1)
            self.sense.set_imu_config(True, True, True)
            orientation = self.sense.get_orientation()
            pitch = orientation['pitch']
            roll = orientation['roll']
            yaw = orientation['yaw']
            ax, ay, az = self.sense.get_accelerometer_raw().values()
            self.heading = round(self.sense.get_compass(), 1)
            if (pitch > 180):
                pitch -= 360
            self.pitch = round(pitch, 1)
            self.roll = round(roll, 1)
            self.yaw = round(yaw, 1)
            self.ax = round(ax, 2)
            self.ay = round(ay, 2)
            self.az = round(az, 2)
            self.altitude = round((288.15 / -0.0065) * ((self.pressure * 100 / 101325) ** (-(8.31432 * -0.0065) / (9.80665 * 0.0289644)) - 1),1)
            """
            self.pitch = r.randint(3, 5)
            self.roll = r.randint(3, 5)
            self.yaw = r.randint(0, 2)
            self.compass = r.randint(240, 241)
            self.temp = r.randint(19, 20)
            self.humidity = r.randint(43, 46)
            self.pressure = r.randint(983, 985)
            self.ax = 0.1
            self.ay = 0.1
            self.az = 0.1
            self.altitude = 286
            """

            # sensors must initialize
            try:
                t=time.time()
                if(time.time()-self.send_timer>delays.BROWSER):
                    sensors_publisher.send_string("%s %s" % (topic.SENSOR_TOPIC, self.getString()))
                    self.send_timer=t
                #print(time.time()-t)
            except:
                print("sensors error")

            time.sleep(delays.SENSOR_REFRESH_DELAY)

    def getString(self):
        return self.joinDelimiter([self.pitch, self.roll, self.yaw, self.heading, self.temp, self.humidity, self.pressure, self.ax, self.ay,
                                   self.az, self.altitude])

    # Update values if instance not doint reading with run()
    def setValues(self,string):
        self.pitch, self.roll, self.yaw, self.heading, self.temp, self.humidity, \
        self.pressure, self.ax, self.ay, self.az, self.altitude = [float(x) for x in string.split(',')]
        if (self.roll > 180):
            self.roll=round(self.roll - 360,1)
예제 #26
0
                    "--line",
                    help="print single line to screen",
                    action="store_true")
parser.add_argument("-o", "--outfile", help="append to file")
args = parser.parse_args()

fmt = "%Y-%m-%d %H:%M:%S %Z"
now = time.localtime()

sense = SenseHat()
temp = sense.get_temperature()
Fahrenheit = 9.0 / 5.0 * temp + 32
humidity = sense.get_humidity()
pressure = sense.get_pressure()
orientation = sense.get_orientation_degrees()
north = sense.get_compass()

sensedatafmt = "%s %.2fC %.2fF %.2frH %.2fmB"
sensedata = (time.strftime(fmt, now), temp, Fahrenheit, humidity, pressure)


def screenprint():
    print("Time: %s" % time.strftime(fmt, now))
    print("Temp: %.2f C" % temp)
    print("Temp: %.2f F" % Fahrenheit)
    print("Humidity: %.2f %%rH" % humidity)
    print("Pressure: %.2f Millibars" % pressure)
    print("Pitch: {pitch:.2f}, Roll: {roll:.2f}, Yaw: {yaw:.2f}".format(
        **orientation))
    print("North: %.2f" % north)
예제 #27
0
led_loop = [
    4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40,
    32, 24, 16, 8, 0, 1, 2, 3
]

sense = SenseHat()
sense.set_rotation(0)
sense.clear()

prev_x = 0
prev_y = 0

led_degree_ratio = len(led_loop) / 360.0

while True:
    dir = sense.get_compass()
    dir_inverted = 360 - dir  # So LED appears to follow North
    led_index = int(led_degree_ratio * dir_inverted)
    offset = led_loop[led_index]

    y = offset // 8  # row
    x = offset % 8  # column

    if x != prev_x or y != prev_y:
        sense.set_pixel(prev_x, prev_y, 0, 0, 0)

    sense.set_pixel(x, y, 0, 0, 255)

    prev_x = x
    prev_y = y
예제 #28
0
class InputModule(AbstractInput):
    """ A sensor support class that measures """
    def __init__(self, input_dev, testing=False):
        super(InputModule, self).__init__(input_dev,
                                          testing=testing,
                                          name=__name__)

        self.sensor = None

        if not testing:
            self.initialize_input()

    def initialize_input(self):
        """ Initialize the Sense HAT sensor class """
        from sense_hat import SenseHat

        self.sensor = SenseHat()

    def get_measurement(self):
        """ Get measurements and store in the database """
        if not self.sensor:
            self.logger.error("Input not set up")
            return

        self.return_dict = copy.deepcopy(measurements_dict)

        if self.is_enabled(0):
            try:
                self.value_set(0, self.sensor.get_temperature())
            except Exception as e:
                self.logger.error(
                    "Temperature (temperature sensor) read failure: {}".format(
                        e))

        if self.is_enabled(1):
            try:
                self.value_set(1, self.sensor.get_temperature_from_humidity())
            except Exception as e:
                self.logger.error(
                    "Temperature (humidity sensor) read failure: {}".format(e))

        if self.is_enabled(2):
            try:
                self.value_set(2, self.sensor.get_temperature_from_pressure())
            except Exception as e:
                self.logger.error(
                    "Temperature (pressure sensor) read failure: {}".format(e))

        if self.is_enabled(3):
            try:
                self.value_set(3, self.sensor.get_humidity())
            except Exception as e:
                self.logger.error("Humidity read failure: {}".format(e))

        if self.is_enabled(4):
            try:
                self.value_set(4, self.sensor.get_pressure())
            except Exception as e:
                self.logger.error("Pressure read failure: {}".format(e))

        if self.is_enabled(5):
            try:
                self.value_set(5, self.sensor.get_compass())
            except Exception as e:
                self.logger.error("Compass read failure: {}".format(e))

        if self.is_enabled(6) or self.is_enabled(7) or self.is_enabled(8):
            magnetism = self.sensor.get_compass_raw()
            if self.is_enabled(6):
                try:
                    self.value_set(6, magnetism["x"])
                except Exception as e:
                    self.logger.error(
                        "Compass raw x read failure: {}".format(e))
            if self.is_enabled(7):
                try:
                    self.value_set(7, magnetism["y"])
                except Exception as e:
                    self.logger.error(
                        "Compass raw y read failure: {}".format(e))
            if self.is_enabled(8):
                try:
                    self.value_set(8, magnetism["z"])
                except Exception as e:
                    self.logger.error(
                        "Compass raw z read failure: {}".format(e))

        if self.is_enabled(9) or self.is_enabled(10) or self.is_enabled(11):
            gyroscope = self.sensor.get_gyroscope()
            if self.is_enabled(9):
                try:
                    self.value_set(9, gyroscope["pitch"])
                except Exception as e:
                    self.logger.error(
                        "Gyroscope pitch read failure: {}".format(e))
            if self.is_enabled(10):
                try:
                    self.value_set(10, gyroscope["roll"])
                except Exception as e:
                    self.logger.error(
                        "Gyroscope roll read failure: {}".format(e))
            if self.is_enabled(11):
                try:
                    self.value_set(11, gyroscope["yaw"])
                except Exception as e:
                    self.logger.error(
                        "Gyroscope yaw read failure: {}".format(e))

        if self.is_enabled(12) or self.is_enabled(13) or self.is_enabled(14):
            acceleration = self.sensor.get_accelerometer_raw()
            if self.is_enabled(12):
                try:
                    self.value_set(12, acceleration["x"])
                except Exception as e:
                    self.logger.error(
                        "Acceleration x read failure: {}".format(e))
            if self.is_enabled(13):
                try:
                    self.value_set(13, acceleration["y"])
                except Exception as e:
                    self.logger.error(
                        "Acceleration y read failure: {}".format(e))
            if self.is_enabled(14):
                try:
                    self.value_set(14, acceleration["z"])
                except Exception as e:
                    self.logger.error(
                        "Acceleration z read failure: {}".format(e))

        return self.return_dict
from sense_hat import SenseHat

sense = SenseHat()

while True:
    bearing = sense.get_compass()
    print('Bearing: {:.0f} to North'.format(bearing))
예제 #30
0
파일: main.py 프로젝트: yaberry/robotics
# Creation des threads
#thread_telemeter = tw.Telemeter(TRIG,ECHO)
myranger = rt.ranger_thread(pi, TRIG, ECHO, 0.3)
#thread_logger = l.Logger(sense, myranger)
# Lancement des threads
myranger.start()
#thread_logger.start()

try:
	print("waiting initialization sensors")
	time.sleep(2)
	
	if ordre=="forward":
		Duration=parameter
		#front
		cap=round(sense.get_compass(),0)
		startcap=cap	
		t=time.time()
		while time.time() < t+Duration:
			ct.setcolor(sense,"forward")	
			mt.forwardto(sense,mymotors,LinearTolerance,cap,myranger)
		mymotors.stop()
		ct.setcolor(sense,"none")
		time.sleep(1)
	
	if ordre=="rotateby":
		deg=parameter
		#rotate 180
		ct.setcolor(sense,"turningby")
		mt.turnby(sense,mymotors,Tolerance,deg)
		mymotors.stop()
예제 #31
0
파일: imu_compass.py 프로젝트: mkhuthir/rpi
#!/usr/bin/python

from sense_hat import SenseHat

sense = SenseHat()

while True:
    print(sense.get_compass())
예제 #32
0
파일: sensors.py 프로젝트: jeryfast/piflyer
class sensors(Thread):
    def __init__(self):
        Thread.__init__(self)
        self.daemon=True
        self.pitch = 0
        self.roll = 0
        self.yaw = 0
        self.compass= 10
        self.temp = 0
        self.humidity = 0
        self.pressure = 0
        self.ax = 0
        self.ay = 0
        self.az = 0
        self.altitude = 0
        # Comment if not running on RPI
        self.sense = SenseHat()
        self.sense.clear()
        self.sense.set_imu_config(True, True, True)

    def joinDelimiter(self, arr):
        tmp=[None]*len(arr)
        for i in range(len(arr)):
            tmp[i]=str(arr[i])
        return ",".join(tmp)

    def getRandomStrArr(self):
        pitch = r.randint(3, 5)
        roll = r.randint(3, 5)
        yaw = r.randint(0, 2)
        compass = r.randint(240, 241)
        temp = r.randint(19, 20)
        humidity = r.randint(43, 46)
        pressure = r.randint(983, 985)
        ax = 0.1
        ay = 0.1
        az = 0.1
        altitude = 286
        return self.joinDelimiter([pitch, roll, yaw, compass, temp, humidity, pressure, ax, ay, az, altitude])

    def run(self):
        while True:
            self.temp = round(self.sense.get_temperature(), 1)
            self.humidity = round(self.sense.get_humidity(), 1)
            self.pressure = round(self.sense.get_pressure(), 2)
            self.sense.set_imu_config(True, True, True)
            pitch, yaw, roll = self.sense.get_orientation().values()
            ax, ay, az = self.sense.get_accelerometer_raw().values()
            self.compass = round(self.sense.get_compass(), 2)
            self.pitch = round(pitch, 2)
            self.roll = round(roll, 2)
            if (self.pitch > 180):
                self.pitch -= 360
            if (self.roll > 180):
                self.roll -=  360
            self.yaw = round(yaw, 2)
            self.ax = round(ax, 2)
            self.ay = round(ay, 2)
            self.az = round(az, 2)
            self.altitude = round((288.15 / -0.0065) * ((self.pressure * 100 / 101325) ** (-(8.31432 * -0.0065) / (9.80665 * 0.0289644)) - 1),2)
            """
            self.pitch = r.randint(3, 5)
            self.roll = r.randint(3, 5)
            self.yaw = r.randint(0, 2)
            self.compass = r.randint(240, 241)
            self.temp = r.randint(19, 20)
            self.humidity = r.randint(43, 46)
            self.pressure = r.randint(983, 985)
            self.ax = 0.1
            self.ay = 0.1
            self.az = 0.1
            self.altitude = 286
            """
            time.sleep(REFRESH_DELAY)


    def getStrArr(self):
        return self.joinDelimiter([self.pitch, self.roll, self.yaw, self.compass, self.temp, self.humidity, self.pressure, self.ax, self.ay,
                                   self.az, self.altitude])
    def getTuple(self):
        return (self.getStrArr(),'')
예제 #33
0
        camera.capture('photos/image%s.jpg' % (count - 1))

    #enviornmental sensors
    humidity = fedora.get_humidity()
    temp = fedora.get_temperature()
    temp_from_humidity = fedora.get_temperature_from_humidity()
    temp_from_pressure = fedora.get_temperature_from_pressure()
    pressure = fedora.get_pressure()
    #get orientation
    orientation = fedora.get_orientation()
    orientation_pitch = orientation.get('pitch')
    orientation_roll = orientation.get('roll')
    orientation_yaw = orientation.get('yaw')

    #get compass
    compass = fedora.get_compass()

    #get gyroscope
    gyro = fedora.get_gyroscope()
    gyro_pitch = gyro.get('pitch')
    gyro_roll = gyro.get('roll')
    gyro_yaw = gyro.get('yaw')

    #get accelerometer
    accelerometer = fedora.get_accelerometer()
    accelerometer_pitch = accelerometer.get('pitch')
    accelerometer_roll = accelerometer.get('roll')
    accelerometer_yaw = accelerometer.get('yaw')

    #write to csv
    with open("atmosphere.csv", 'a') as atm:
예제 #34
0
    print(
        "************************ 1 second pass ******************************"
    )

    # Enabling Magnetometer (compass), Gyroscope and Accelerometer
    sense.set_imu_config(True, True, True)

    # Getting orientation data
    orientation = sense.get_orientation()
    orientationRadians = sense.get_orientation_radians()
    orientationDegrees = sense.get_orientation_degrees()

    # Getting magnetometer data
    magnetometerRaw = sense.get_compass_raw()
    magnetometerNorth = sense.get_compass()

    # Getting gyroscope data
    gyroscopeRaw = sense.get_gyroscope_raw()
    gyroscope = sense.get_gyroscope()

    # Getting accelerometer data
    accelerometerRaw = sense.get_accelerometer_raw()
    accelerometer = sense.get_accelerometer()

    # Printing orientation data
    print("**************** ORIENTATION DATA ***********************")
    print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientation))
    print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientationRadians))
    print("p: {pitch}, r: {roll}, y: {yaw}".format(**orientationDegrees))
from sense_hat import SenseHat
import time

sh = SenseHat()
while True:
    # 磁気センサの生データ。Dicitonary型
    raw = sh.get_compass_raw()
    x_val = round(float(raw['x']),2)
    y_val = round(float(raw['y']),2)
    z_val = round(float(raw['z']),2)
    
    
    # 北からの位置を取得。加速度センサと磁気センサの値から計算している。範囲は0〜360、単位は度。0が北、180が南。
    # 値はゆっくり変化していく、方位磁石のほうが精度が良い
    north = sh.get_compass()
    print("North: %s (x=%s, y=%s, z=%s)" %(north, x_val, y_val, z_val))
    time.sleep(1)
    SH_temp = sense.get_temperature()           # value in degrees C
    SH_pressure = sense.get_pressure() * 100    # convert output from millibars to Pascals for consistency
    SH_humidity = sense.get_humidity()          # % relative humidity


    # Orientation
    sense.set_imu_config(True,True,True)        # Enable compass, gyro, and accelerometer
    SH_orientation = sense.get_orientation()    # orientation of pitch, roll, yaw axes in degrees
    SH_orientation_x = SH_orientation.get('x')
    SH_orientation_y = SH_orientation.get('y')
    SH_orientation_z = SH_orientation.get('z')

    # Magnetometer data
    #sense.set_imu_config(True,False,False)
    time.sleep(0.01) # sleep for 10 ms after changing IMU configuration
    SH_compass_north = sense.get_compass()      # direction of magnetometer from North, in degrees
    SH_compass_raw = sense.get_compass_raw()    # magnetic intensity of x, y, z axes in microteslas
    SH_compass_raw_x = SH_compass_raw.get('x')
    SH_compass_raw_y = SH_compass_raw.get('y')
    SH_compass_raw_z = SH_compass_raw.get('z')

    # Gyro Data
    #sense.set_imu_config(False,True,False)
    time.sleep(0.01) # sleep for 10 ms after changing IMU configuration
    #SH_gyro = sense.get_gyroscope()             # orientation of pitch, roll, yaw axes in degrees
    SH_gyro_raw = sense.get_gyroscope_raw()     # rotational velocity of pitch, roll, yaw axes in radians per sec
    SH_gyro_raw_x = SH_gyro_raw.get('x')
    SH_gyro_raw_y = SH_gyro_raw.get('y')
    SH_gyro_raw_z = SH_gyro_raw.get('z')

    # Accelerometer data
예제 #37
0
# The calibration program will produce the file RTIMULib.ini
# Copy it into the same folder as your Python code

led_loop = [4, 5, 6, 7, 15, 23, 31, 39, 47, 55, 63, 62, 61, 60, 59, 58, 57, 56, 48, 40, 32, 24, 16, 8, 0, 1, 2, 3]

sense = SenseHat()
sense.set_rotation(0)
sense.clear()

prev_x = 0
prev_y = 0

led_degree_ratio = len(led_loop) / 360.0

while True:
    dir = sense.get_compass()
    dir_inverted = 360 - dir  # So LED appears to follow North
    led_index = int(led_degree_ratio * dir_inverted)
    offset = led_loop[led_index]

    y = offset // 8  # row
    x = offset % 8  # column

    if x != prev_x or y != prev_y:
        sense.set_pixel(prev_x, prev_y, 0, 0, 0)

    sense.set_pixel(x, y, 0, 0, 255)

    prev_x = x
prev_y = y
예제 #38
0
from sense_hat import SenseHat

sense = SenseHat()

humidity = round(sense.get_humidity(), 2)
temp = round(sense.get_temperature(), 2)
pressure = round(sense.get_pressure(), 2)
north = round(sense.get_compass(), 2)

print(humidity)
print(temp)
print(pressure)
print(north)
예제 #39
0
# set the interval between each iteraction.
# The interval is configured to 0 by default
DATA_INTERVAL = 0

while True:

    try:
        # Blink a let before each sensor read
        if DATA_INTERVAL > 0:
            blink_led()

        acceleration = sense.get_accelerometer_raw()
        x = acceleration['x']
        y = acceleration['y']
        z = acceleration['z']
        direction = sense.get_compass()

        # create the message (JSON format)
        payload = '{{ "timestamp": {}, "device_id": "{}", "accel_x":{}, "accel_y":{}, "accel_z":{}, "direction":{} }}'.format(
            int(time.time()), device_id, x, y, z, direction)
        # send the data to the Cloud
        client.publish(_MQTT_TOPIC, payload, qos=1)

        # Print the event (just for debugging)
        print("{}\n".format(payload))

        if DATA_INTERVAL > 0:
            time.sleep(DATA_INTERVAL)

    except KeyboardInterrupt:
        # Stop the Googgle Cloud Client when CTRL+C was pressed
예제 #40
0
sh.set_pixels(locked_screen)

### unlock function ###


def unlock():
    """unlocking function"""

    sh.set_pixels(unlocked_screen)
    sleep(2)
    sh.show_message("You have unlocked it!!")


### locks ###

while True:
    if round(sh.get_humidity()) >= 50:
        unlocked1 = True

    if unlocked1 == True and round(int(sh.get_compass())):
        unlocked2 = True

    if unlocked2 == True and round(sh.get_temperature()) >= 26:
        unlocked3 = True

    if unlocked3 == True and round(int(sh.get_accelerometer()['roll'])) >= 57:
        unlocked4 = True
        unlock()
        quit()