class Sensors(object):
def __init__(self):
self.__ipcon = IPConnection('localhost', 4223)
def __del__(self):
self.__ipcon.destroy()
def add(self, pSensor):
self.__ipcon.add_device(pSensor)
class Q:
HOST = "localhost"
PORT = 4223
UID = "aeoUQwwyAvY" # Change to your UID
def __init__(self):
self.base_x = 0.0
self.base_y = 0.0
self.base_z = 0.0
self.base_w = 0.0
self.imu = IMU(self.UID) # Create device object
self.ipcon = IPConnection(self.HOST, self.PORT) # Create IPconnection to brickd
self.ipcon.add_device(self.imu) # Add device to IP connection
# Don't use device before it is added to a connection
# Wait for IMU to settle
print 'Set IMU to base position and wait for 10 seconds'
print 'Base position will be 0 for all angles'
time.sleep(10)
q = self.imu.get_quaternion()
self.set_base_coordinates(q.x, q.y, q.z, q.w)
# Set period for quaternion callback to 10ms
self.imu.set_quaternion_period(10)
# Register quaternion callback
self.imu.register_callback(self.imu.CALLBACK_QUATERNION, self.quaternion_cb)
def quaternion_cb(self, x, y, z, w):
# Use conjugate of quaternion to rotate coordinates according to base system
x, y, z, w = self.make_relative_coordinates(-x, -y, -z, w)
x_angle = int(math.atan2(2.0*(y*z - w*x), 1.0 - 2.0*(x*x + y*y))*180/math.pi)
y_angle = int(math.atan2(2.0*(x*z + w*y), 1.0 - 2.0*(x*x + y*y))*180/math.pi)
z_angle = int(math.atan2(2.0*(x*y + w*z), 1.0 - 2.0*(x*x + z*z))*180/math.pi)
print 'x: {0}, y: {1}, z: {2}'.format(x_angle, y_angle, z_angle)
def set_base_coordinates(self, x, y, z, w):
self.base_x = x
self.base_y = y
self.base_z = z
self.base_w = w
def make_relative_coordinates(self, x, y, z, w):
# Multiply base quaternion with current quaternion
return (
w * self.base_x + x * self.base_w + y * self.base_z - z * self.base_y,
w * self.base_y - x * self.base_z + y * self.base_w + z * self.base_x,
w * self.base_z + x * self.base_y - y * self.base_x + z * self.base_w,
w * self.base_w - x * self.base_x - y * self.base_y - z * self.base_z
)
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UID = "a4JritAp6Go" # Change to your UID
from tinkerforge.ip_connection import IPConnection
from tinkerforge.brick_imu import IMU
imu = IMU(UID) # Create device object
# Quaternion callback
def quaternion_cb(x, y, z, w):
print("x: " + str(x) + "\ny: " + str(y) + "\nz: " + str(z) + "\nw: " + str(w) + "\n")
if __name__ == "__main__":
ipcon = IPConnection(HOST, PORT) # Create IPconnection to brickd
ipcon.add_device(imu) # Add device to IP connection
# Don't use device before it is added to a connection
# Set period for quaternion callback to 1s
imu.set_quaternion_period(100)
# Register quaternion callback
imu.register_callback(imu.CALLBACK_QUATERNION, quaternion_cb)
imu.leds_off() # Turn LEDs off.
raw_input('Press key to exit\n') # Use input() in Python 3
ipcon.destroy()
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from tinkerforge.ip_connection import IPConnection
from tinkerforge.bricklet_gps import GPS
from settings import HOST, PORT, GPSUID
from array import array
ipcon = IPConnection(HOST, PORT) # Create ip connection to brickd
gps = GPS(GPSUID) # Create device object
ipcon.add_device(gps) # Add device to ip connection
coords = gps.get_coordinates()
lon = coords.longitude/1000000.0
lat = coords.latitude/1000000.0
print('Latitude: ' + str(lat) + '° ' + coords.ns)
print('Longitude: ' + str(lon/1000000.0) + '° ' + coords.ew)
if coords.ns == "S":
lat = 0 - lat
if coords.ew == "W":
lon = 0 - lon
arr = array(lat, lon)
try:
# This will create a new file or **overwrite an existing file**.
f = open("location.txt", "w")
try:
arr.tofile(f)
finally:
# hier soll spaeter die Webcam gezeigt werden
screen = pygame.display.set_mode((200, 200))
# Wird benoetigt um die KeyWiederholung zu realisieren
clock = pygame.time.Clock()
# Create IP connection to brickd
ipcon = IPConnection(HOST, PORT)
# Create device objects
dc0 = DC(UIDdc0)
dc1 = DC(UIDdc1)
lcd = LCD20x4(UIDdpl)
mst = Master(UIDmaster)
# Connect to devices
ipcon.add_device(dc0)
ipcon.add_device(dc1)
ipcon.add_device(lcd)
ipcon.add_device(mst)
# Hier wird ein Initial Program gestartet um eventuelle sonderwuensche entgegenzunehmen
velol = 0
velor = 0
hz = 0
acc = 0
getVars(velol, velor, hz, acc)
#Hier der zweite thread der sich um die Steuerung kuemmert, er laueft deutlich schneller!
#Hier wird nun auch der Status abgefragt - ca. je 1sec * 6 / 1000 !!
Control(velol, velor, hz, acc)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UIDm = "9p19drqHQdS" # Change to your UID
from tinkerforge.ip_connection import IPConnection
from tinkerforge.brick_master import Master
#from tinkerforge.brick_dc import DC
#from tinkerforge.bricklet_lcd_20x4 import LCD20x4
ipcon = IPConnection(HOST, PORT) # Create IP connection to brickd
master = Master(UIDm) # Create device object
ipcon.add_device(master) # Add device to IP connection
# Get voltage and current from stack (in mV/mA)
voltage = master.get_stack_voltage()
current = master.get_stack_current()
tempera = master.get_chip_temperature()
# Print Voltage, Current and Temperature from Master
print('Stack Voltage: ' + str(voltage / 1000.0) + ' V')
print('Stack Current: ' + str(current / 1000.0) + ' A')
print('Stack Tempera: ' + str(tempera / 10) + ' °C')
else:
steps = random.randint(-5000, -1000) # steps (backward)
print('Driving backward: ' + str(steps) + ' steps')
vel = random.randint(200, 2000) # steps/s
acc = random.randint(100, 1000) # steps/s^2
dec = random.randint(100, 1000) # steps/s^2
print('Configuration (vel, acc, dec): ' + str((vel, acc, dec)))
stepper.set_speed_ramping(acc, dec)
stepper.set_max_velocity(vel)
stepper.set_steps(steps)
if __name__ == "__main__":
ipcon = IPConnection(HOST, PORT) # Create IP connection to brickd
stepper = Stepper(UID) # Create device object
ipcon.add_device(stepper) # Add device to IP connection
# Don't use device before it is added to a connection
# Register "position reached callback" to cb_reached
# cb_reached will be called every time a position set with
# set_steps or set_target_position is reached
stepper.register_callback(stepper.CALLBACK_POSITION_REACHED, cb_reached)
stepper.enable()
stepper.set_steps(1) # Drive one step forward to get things going
raw_input('Press key to exit\n') # Use input() in Python 3
ipcon.destroy()
class TomIMU: def __init__(self,host,port,uid,callbackPeriodMS=100): self.host=host self.port=port self.uid=uid self._imu = IMU(uid) # Create device object self._ipcon = IPConnection(self.host,self.port) # Create IPconnection to brickd self._ipcon.add_device(self._imu) # Add device to IP connection self.ready = True # Don't use device before it is added to a connection # Set period for quaternion callback (defaults to 100ms) self._imu.set_quaternion_period(callbackPeriodMS) # Register quaternion callback self._imu.register_callback(self._imu.CALLBACK_QUATERNION, self._QuaternionCallback) self._imu.leds_off() # Turn LEDs off. self._imu.set_convergence_speed(5) # 5ms convergence. # Orientation origin and most recent values q = self._imu.get_quaternion() # Get a temp quaternion from current pose. self.rel_x = q.x self.rel_y = q.y self.rel_z = q.z self.rel_w = q.w self.x = q.x self.y = q.y self.z = q.z self.w = q.w def __destroy__(self): self._ipcon.destroy() def _QuaternionCallback(self, x, y, z, w): """ Records the most recent quaternion orientation values. """ self.x,self.y,self.z,self.w = x,y,z,w def SetOrientationOrigin(self, origin=None): """ Resets the orientation origin to the given values, or the latest reading if none. """ if origin is None: self.rel_x, self.rel_y, self.rel_z, self.rel_w = self.x, self.y, self.z, self.w else: self.rel_x, self.rel_y, self.rel_z, self.rel_w = origin def GetEulerOrientation(self): x,y,z,w = self.GetQuaternionOrientation() from math import atan2, asin roll = atan2(2.0*y*w - 2.0*x*z, 1.0 - 2.0*y*y - 2.0*z*z) pitch = atan2(2.0*x*w - 2.0*y*z, 1.0 - 2.0*x*x - 2.0*z*z) yaw = asin(2.0*x*y + 2.0*z*w) return roll,pitch,yaw def GetQuaternionOrientation(self): # Conjugate x,y,z = -self.x, -self.y, -self.z w = self.w # Multiply wn = w * self.rel_w - x * self.rel_x - y * self.rel_y - z * self.rel_z xn = w * self.rel_x + x * self.rel_w + y * self.rel_z - z * self.rel_y yn = w * self.rel_y - x * self.rel_z + y * self.rel_w + z * self.rel_x zn = w * self.rel_z + x * self.rel_y - y * self.rel_x + z * self.rel_w return xn,yn,zn,wn def GetConvergenceSpeed(self): return self._imu.get_convergence_speed() def SetConvergenceSpeed(self, speed): self._imu.set_convergence_speed(speed)
enable = True
else:
enable = False
print("stop!!!1")
servo.set_position(steeringsrv, mid)
servo.set_position(motor, stop)
if __name__ == "__main__":
enable = False
ipcon = IPConnection(HOST, PORT) # Create ip connection to brickd
gps = GPS(GPSUID) # Create device object
ipcon.add_device(gps) # Add device to ip connection
servo = Servo(SERVOUID) # Create device object
ipcon.add_device(servo) # Add device to IP connection
# Don't use device before it is added to a connection
servo.set_degree(motor, -9000, 9000)
servo.set_pulse_width(motor, 950, 1950)
servo.set_period(motor, 20000)
servo.set_acceleration(motor, 7000)
servo.set_velocity(motor, 0xFFFF) # Full speed
servo.set_degree(steeringsrv, -3600, 3600)
servo.set_pulse_width(steeringsrv, 955, 2000)
servo.set_period(steeringsrv, 20000)
servo.set_acceleration(steeringsrv, 7000) # Full acceleration 0xFFFF
servo.set_velocity(steeringsrv, 0xFFFF) # Full speed
# hier soll spaeter die Webcam gezeigt werden
screen = pygame.display.set_mode((200, 200))
# Wird benoetigt um die KeyWiederholung zu realisieren
clock = pygame.time.Clock()
# Create IP connection to brickd
ipcon = IPConnection(HOST, PORT)
# Create device objects
dc0 = DC(UIDdc0)
dc1 = DC(UIDdc1)
lcd = LCD20x4(UIDdpl)
mst = Master(UIDmaster)
# Connect to devices
ipcon.add_device(dc0)
ipcon.add_device(dc1)
ipcon.add_device(lcd)
ipcon.add_device(mst)
# Hier wird ein Initial Program gestartet um eventuelle sonderwuensche entgegenzunehmen
velol = 0
velor = 0
hz = 0
acc = 0
getVars(velol, velor, hz, acc)
# Hier der zweite thread der sich um die Steuerung kuemmert, er laueft deutlich schneller!
# Hier wird nun auch der Status abgefragt - ca. je 1sec * 6 / 1000 !!
Control(velol, velor, hz, acc)
UID_TEMPERATURE = "bPf"
UID_BAROMETER = "bNs"
from tinkerforge.ip_connection import IPConnection
from tinkerforge.brick_master import Master
from tinkerforge.bricklet_lcd_20x4 import LCD20x4
from tinkerforge.bricklet_temperature import Temperature
from tinkerforge.bricklet_barometer import Barometer
from string_magic import unicode_to_ks0066u
if __name__ == "__main__":
ipcon = IPConnection(HOST, PORT) # Create IP connection to brick
master = Master(UID_MASTER) # Create device object
ipcon.add_device(master) # Add device to IP connection
# Don't use device before it is added to a connection
## Get voltage and current from stack (in mV / mA)
#voltage = master.get_stack_voltage()
#current = master.get_stack_current()
##print('Stack Voltage: ' + str(voltage / 1000.0) + ' V')
##print('Stack Current: ' + str(current / 1000.0) + ' A')
t = Temperature(UID_TEMPERATURE) # Create temperature object
ipcon.add_device(t) # Add device to IP connection
# Don't use device before it is added to connection
# Get current temperature (unit is °C/ 100)
temperature = t.get_temperature() / 100.0
#!/usr/bin/env python
# -*- coding: utf-8 -*-
HOST = "localhost"
PORT = 4223
UIDm = "9p19drqHQdS" # Change to your UID
from tinkerforge.ip_connection import IPConnection
from tinkerforge.brick_master import Master
#from tinkerforge.brick_dc import DC
#from tinkerforge.bricklet_lcd_20x4 import LCD20x4
ipcon = IPConnection(HOST, PORT) # Create IP connection to brickd
master = Master(UIDm) # Create device object
ipcon.add_device(master) # Add device to IP connection
# Get voltage and current from stack (in mV/mA)
voltage = master.get_stack_voltage()
current = master.get_stack_current()
tempera = master.get_chip_temperature()
# Print Voltage, Current and Temperature from Master
print('Stack Voltage: ' + str(voltage/1000.0) + ' V')
print('Stack Current: ' + str(current/1000.0) + ' A')
print('Stack Tempera: ' + str(tempera/10) + ' °C')
