tinkerforge 2.0.7
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/lib/tinkerforge.rb +5 -0
- data/lib/tinkerforge/brick_dc.rb +359 -0
- data/lib/tinkerforge/brick_imu.rb +512 -0
- data/lib/tinkerforge/brick_master.rb +1120 -0
- data/lib/tinkerforge/brick_servo.rb +475 -0
- data/lib/tinkerforge/brick_stepper.rb +556 -0
- data/lib/tinkerforge/bricklet_ambient_light.rb +246 -0
- data/lib/tinkerforge/bricklet_analog_in.rb +273 -0
- data/lib/tinkerforge/bricklet_analog_out.rb +90 -0
- data/lib/tinkerforge/bricklet_barometer.rb +313 -0
- data/lib/tinkerforge/bricklet_current12.rb +274 -0
- data/lib/tinkerforge/bricklet_current25.rb +274 -0
- data/lib/tinkerforge/bricklet_distance_ir.rb +274 -0
- data/lib/tinkerforge/bricklet_dual_relay.rb +127 -0
- data/lib/tinkerforge/bricklet_gps.rb +301 -0
- data/lib/tinkerforge/bricklet_humidity.rb +245 -0
- data/lib/tinkerforge/bricklet_industrial_digital_in_4.rb +165 -0
- data/lib/tinkerforge/bricklet_industrial_digital_out_4.rb +177 -0
- data/lib/tinkerforge/bricklet_industrial_quad_relay.rb +177 -0
- data/lib/tinkerforge/bricklet_io16.rb +237 -0
- data/lib/tinkerforge/bricklet_io4.rb +236 -0
- data/lib/tinkerforge/bricklet_joystick.rb +274 -0
- data/lib/tinkerforge/bricklet_lcd_16x2.rb +175 -0
- data/lib/tinkerforge/bricklet_lcd_20x4.rb +231 -0
- data/lib/tinkerforge/bricklet_linear_poti.rb +241 -0
- data/lib/tinkerforge/bricklet_piezo_buzzer.rb +84 -0
- data/lib/tinkerforge/bricklet_ptc.rb +277 -0
- data/lib/tinkerforge/bricklet_rotary_poti.rb +241 -0
- data/lib/tinkerforge/bricklet_temperature.rb +188 -0
- data/lib/tinkerforge/bricklet_temperature_ir.rb +275 -0
- data/lib/tinkerforge/bricklet_voltage.rb +241 -0
- data/lib/tinkerforge/bricklet_voltage_current.rb +386 -0
- data/lib/tinkerforge/ip_connection.rb +1027 -0
- data/lib/tinkerforge/version.rb +4 -0
- metadata +98 -0
data/lib/tinkerforge.rb
ADDED
@@ -0,0 +1,359 @@
|
|
1
|
+
# -*- ruby encoding: utf-8 -*-
|
2
|
+
#############################################################
|
3
|
+
# This file was automatically generated on 2013-05-16. #
|
4
|
+
# #
|
5
|
+
# Bindings Version 2.0.7 #
|
6
|
+
# #
|
7
|
+
# If you have a bugfix for this file and want to commit it, #
|
8
|
+
# please fix the bug in the generator. You can find a link #
|
9
|
+
# to the generator git on tinkerforge.com #
|
10
|
+
#############################################################
|
11
|
+
|
12
|
+
module Tinkerforge
|
13
|
+
# Device for controlling DC motors
|
14
|
+
class BrickDC < Device
|
15
|
+
DEVICE_IDENTIFIER = 11 # :nodoc:
|
16
|
+
|
17
|
+
# This callback is triggered when the input voltage drops below the value set by
|
18
|
+
# BrickDC#set_minimum_voltage. The parameter is the current voltage given
|
19
|
+
# in mV.
|
20
|
+
CALLBACK_UNDER_VOLTAGE = 21
|
21
|
+
|
22
|
+
# This callback is triggered if either the current consumption
|
23
|
+
# is too high (above 5A) or the temperature of the driver chip is too high
|
24
|
+
# (above 175°C). These two possibilities are essentially the same, since the
|
25
|
+
# temperature will reach this threshold immediately if the motor consumes too
|
26
|
+
# much current. In case of a voltage below 3.3V (external or stack) this
|
27
|
+
# callback is triggered as well.
|
28
|
+
#
|
29
|
+
# If this callback is triggered, the driver chip gets disabled at the same time.
|
30
|
+
# That means, BrickDC#enable has to be called to drive the motor again.
|
31
|
+
#
|
32
|
+
# .. note::
|
33
|
+
# This callback only works in Drive/Brake mode (see BrickDC#set_drive_mode). In
|
34
|
+
# Drive/Coast mode it is unfortunately impossible to reliably read the
|
35
|
+
# overcurrent/overtemperature signal from the driver chip.
|
36
|
+
CALLBACK_EMERGENCY_SHUTDOWN = 22
|
37
|
+
|
38
|
+
# This callback is triggered whenever a set velocity is reached. For example:
|
39
|
+
# If a velocity of 0 is present, acceleration is set to 5000 and velocity
|
40
|
+
# to 10000, CALLBACK_VELOCITY_REACHED will be triggered after about 2 seconds, when
|
41
|
+
# the set velocity is actually reached.
|
42
|
+
#
|
43
|
+
# .. note::
|
44
|
+
# Since we can't get any feedback from the DC motor, this only works if the
|
45
|
+
# acceleration (see BrickDC#set_acceleration) is set smaller or equal to the
|
46
|
+
# maximum acceleration of the motor. Otherwise the motor will lag behind the
|
47
|
+
# control value and the callback will be triggered too early.
|
48
|
+
CALLBACK_VELOCITY_REACHED = 23
|
49
|
+
|
50
|
+
# This callback is triggered with the period that is set by
|
51
|
+
# BrickDC#set_current_velocity_period. The parameter is the *current* velocity
|
52
|
+
# used by the motor.
|
53
|
+
#
|
54
|
+
# CALLBACK_CURRENT_VELOCITY is only triggered after the set period if there is
|
55
|
+
# a change in the velocity.
|
56
|
+
CALLBACK_CURRENT_VELOCITY = 24
|
57
|
+
|
58
|
+
FUNCTION_SET_VELOCITY = 1 # :nodoc:
|
59
|
+
FUNCTION_GET_VELOCITY = 2 # :nodoc:
|
60
|
+
FUNCTION_GET_CURRENT_VELOCITY = 3 # :nodoc:
|
61
|
+
FUNCTION_SET_ACCELERATION = 4 # :nodoc:
|
62
|
+
FUNCTION_GET_ACCELERATION = 5 # :nodoc:
|
63
|
+
FUNCTION_SET_PWM_FREQUENCY = 6 # :nodoc:
|
64
|
+
FUNCTION_GET_PWM_FREQUENCY = 7 # :nodoc:
|
65
|
+
FUNCTION_FULL_BRAKE = 8 # :nodoc:
|
66
|
+
FUNCTION_GET_STACK_INPUT_VOLTAGE = 9 # :nodoc:
|
67
|
+
FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE = 10 # :nodoc:
|
68
|
+
FUNCTION_GET_CURRENT_CONSUMPTION = 11 # :nodoc:
|
69
|
+
FUNCTION_ENABLE = 12 # :nodoc:
|
70
|
+
FUNCTION_DISABLE = 13 # :nodoc:
|
71
|
+
FUNCTION_IS_ENABLED = 14 # :nodoc:
|
72
|
+
FUNCTION_SET_MINIMUM_VOLTAGE = 15 # :nodoc:
|
73
|
+
FUNCTION_GET_MINIMUM_VOLTAGE = 16 # :nodoc:
|
74
|
+
FUNCTION_SET_DRIVE_MODE = 17 # :nodoc:
|
75
|
+
FUNCTION_GET_DRIVE_MODE = 18 # :nodoc:
|
76
|
+
FUNCTION_SET_CURRENT_VELOCITY_PERIOD = 19 # :nodoc:
|
77
|
+
FUNCTION_GET_CURRENT_VELOCITY_PERIOD = 20 # :nodoc:
|
78
|
+
FUNCTION_GET_PROTOCOL1_BRICKLET_NAME = 241 # :nodoc:
|
79
|
+
FUNCTION_GET_CHIP_TEMPERATURE = 242 # :nodoc:
|
80
|
+
FUNCTION_RESET = 243 # :nodoc:
|
81
|
+
FUNCTION_GET_IDENTITY = 255 # :nodoc:
|
82
|
+
|
83
|
+
DRIVE_MODE_DRIVE_BRAKE = 0 # :nodoc:
|
84
|
+
DRIVE_MODE_DRIVE_COAST = 1 # :nodoc:
|
85
|
+
|
86
|
+
# Creates an object with the unique device ID <tt>uid</tt> and adds it to
|
87
|
+
# the IP Connection <tt>ipcon</tt>.
|
88
|
+
def initialize(uid, ipcon)
|
89
|
+
super uid, ipcon
|
90
|
+
|
91
|
+
@api_version = [2, 0, 0]
|
92
|
+
|
93
|
+
@response_expected[FUNCTION_SET_VELOCITY] = RESPONSE_EXPECTED_FALSE
|
94
|
+
@response_expected[FUNCTION_GET_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
95
|
+
@response_expected[FUNCTION_GET_CURRENT_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
96
|
+
@response_expected[FUNCTION_SET_ACCELERATION] = RESPONSE_EXPECTED_FALSE
|
97
|
+
@response_expected[FUNCTION_GET_ACCELERATION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
98
|
+
@response_expected[FUNCTION_SET_PWM_FREQUENCY] = RESPONSE_EXPECTED_FALSE
|
99
|
+
@response_expected[FUNCTION_GET_PWM_FREQUENCY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
100
|
+
@response_expected[FUNCTION_FULL_BRAKE] = RESPONSE_EXPECTED_FALSE
|
101
|
+
@response_expected[FUNCTION_GET_STACK_INPUT_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
102
|
+
@response_expected[FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
103
|
+
@response_expected[FUNCTION_GET_CURRENT_CONSUMPTION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
104
|
+
@response_expected[FUNCTION_ENABLE] = RESPONSE_EXPECTED_FALSE
|
105
|
+
@response_expected[FUNCTION_DISABLE] = RESPONSE_EXPECTED_FALSE
|
106
|
+
@response_expected[FUNCTION_IS_ENABLED] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
107
|
+
@response_expected[FUNCTION_SET_MINIMUM_VOLTAGE] = RESPONSE_EXPECTED_TRUE
|
108
|
+
@response_expected[FUNCTION_GET_MINIMUM_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
109
|
+
@response_expected[FUNCTION_SET_DRIVE_MODE] = RESPONSE_EXPECTED_FALSE
|
110
|
+
@response_expected[FUNCTION_GET_DRIVE_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
111
|
+
@response_expected[FUNCTION_SET_CURRENT_VELOCITY_PERIOD] = RESPONSE_EXPECTED_TRUE
|
112
|
+
@response_expected[FUNCTION_GET_CURRENT_VELOCITY_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
113
|
+
@response_expected[CALLBACK_UNDER_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
114
|
+
@response_expected[CALLBACK_EMERGENCY_SHUTDOWN] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
115
|
+
@response_expected[CALLBACK_VELOCITY_REACHED] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
116
|
+
@response_expected[CALLBACK_CURRENT_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
117
|
+
@response_expected[FUNCTION_GET_PROTOCOL1_BRICKLET_NAME] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
118
|
+
@response_expected[FUNCTION_GET_CHIP_TEMPERATURE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
119
|
+
@response_expected[FUNCTION_RESET] = RESPONSE_EXPECTED_FALSE
|
120
|
+
@response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
121
|
+
|
122
|
+
@callback_formats[CALLBACK_UNDER_VOLTAGE] = 'S'
|
123
|
+
@callback_formats[CALLBACK_EMERGENCY_SHUTDOWN] = ''
|
124
|
+
@callback_formats[CALLBACK_VELOCITY_REACHED] = 's'
|
125
|
+
@callback_formats[CALLBACK_CURRENT_VELOCITY] = 's'
|
126
|
+
end
|
127
|
+
|
128
|
+
# Sets the velocity of the motor. Whereas -32767 is full speed backward,
|
129
|
+
# 0 is stop and 32767 is full speed forward. Depending on the
|
130
|
+
# acceleration (see BrickDC#set_acceleration), the motor is not immediately
|
131
|
+
# brought to the velocity but smoothly accelerated.
|
132
|
+
#
|
133
|
+
# The velocity describes the duty cycle of the PWM with which the motor is
|
134
|
+
# controlled, e.g. a velocity of 3277 sets a PWM with a 10% duty cycle.
|
135
|
+
# You can not only control the duty cycle of the PWM but also the frequency,
|
136
|
+
# see BrickDC#set_pwm_frequency.
|
137
|
+
#
|
138
|
+
# The default velocity is 0.
|
139
|
+
def set_velocity(velocity)
|
140
|
+
send_request(FUNCTION_SET_VELOCITY, [velocity], 's', 0, '')
|
141
|
+
end
|
142
|
+
|
143
|
+
# Returns the velocity as set by BrickDC#set_velocity.
|
144
|
+
def get_velocity
|
145
|
+
send_request(FUNCTION_GET_VELOCITY, [], '', 2, 's')
|
146
|
+
end
|
147
|
+
|
148
|
+
# Returns the *current* velocity of the motor. This value is different
|
149
|
+
# from BrickDC#get_velocity whenever the motor is currently accelerating
|
150
|
+
# to a goal set by BrickDC#set_velocity.
|
151
|
+
def get_current_velocity
|
152
|
+
send_request(FUNCTION_GET_CURRENT_VELOCITY, [], '', 2, 's')
|
153
|
+
end
|
154
|
+
|
155
|
+
# Sets the acceleration of the motor. It is given in *velocity/s*. An
|
156
|
+
# acceleration of 10000 means, that every second the velocity is increased
|
157
|
+
# by 10000 (or about 30% duty cycle).
|
158
|
+
#
|
159
|
+
# For example: If the current velocity is 0 and you want to accelerate to a
|
160
|
+
# velocity of 16000 (about 50% duty cycle) in 10 seconds, you should set
|
161
|
+
# an acceleration of 1600.
|
162
|
+
#
|
163
|
+
# If acceleration is set to 0, there is no speed ramping, i.e. a new velocity
|
164
|
+
# is immediately given to the motor.
|
165
|
+
#
|
166
|
+
# The default acceleration is 10000.
|
167
|
+
def set_acceleration(acceleration)
|
168
|
+
send_request(FUNCTION_SET_ACCELERATION, [acceleration], 'S', 0, '')
|
169
|
+
end
|
170
|
+
|
171
|
+
# Returns the acceleration as set by BrickDC#set_acceleration.
|
172
|
+
def get_acceleration
|
173
|
+
send_request(FUNCTION_GET_ACCELERATION, [], '', 2, 'S')
|
174
|
+
end
|
175
|
+
|
176
|
+
# Sets the frequency (in Hz) of the PWM with which the motor is driven.
|
177
|
+
# The possible range of the frequency is 1-20000Hz. Often a high frequency
|
178
|
+
# is less noisy and the motor runs smoother. However, with a low frequency
|
179
|
+
# there are less switches and therefore fewer switching losses. Also with
|
180
|
+
# most motors lower frequencies enable higher torque.
|
181
|
+
#
|
182
|
+
# If you have no idea what all this means, just ignore this function and use
|
183
|
+
# the default frequency, it will very likely work fine.
|
184
|
+
#
|
185
|
+
# The default frequency is 15 kHz.
|
186
|
+
def set_pwm_frequency(frequency)
|
187
|
+
send_request(FUNCTION_SET_PWM_FREQUENCY, [frequency], 'S', 0, '')
|
188
|
+
end
|
189
|
+
|
190
|
+
# Returns the PWM frequency (in Hz) as set by BrickDC#set_pwm_frequency.
|
191
|
+
def get_pwm_frequency
|
192
|
+
send_request(FUNCTION_GET_PWM_FREQUENCY, [], '', 2, 'S')
|
193
|
+
end
|
194
|
+
|
195
|
+
# Executes an active full brake.
|
196
|
+
#
|
197
|
+
# .. warning::
|
198
|
+
# This function is for emergency purposes,
|
199
|
+
# where an immediate brake is necessary. Depending on the current velocity and
|
200
|
+
# the strength of the motor, a full brake can be quite violent.
|
201
|
+
#
|
202
|
+
# Call BrickDC#set_velocity with 0 if you just want to stop the motor.
|
203
|
+
def full_brake
|
204
|
+
send_request(FUNCTION_FULL_BRAKE, [], '', 0, '')
|
205
|
+
end
|
206
|
+
|
207
|
+
# Returns the stack input voltage in mV. The stack input voltage is the
|
208
|
+
# voltage that is supplied via the stack, i.e. it is given by a
|
209
|
+
# Step-Down or Step-Up Power Supply.
|
210
|
+
def get_stack_input_voltage
|
211
|
+
send_request(FUNCTION_GET_STACK_INPUT_VOLTAGE, [], '', 2, 'S')
|
212
|
+
end
|
213
|
+
|
214
|
+
# Returns the external input voltage in mV. The external input voltage is
|
215
|
+
# given via the black power input connector on the DC Brick.
|
216
|
+
#
|
217
|
+
# If there is an external input voltage and a stack input voltage, the motor
|
218
|
+
# will be driven by the external input voltage. If there is only a stack
|
219
|
+
# voltage present, the motor will be driven by this voltage.
|
220
|
+
#
|
221
|
+
# .. warning::
|
222
|
+
# This means, if you have a high stack voltage and a low external voltage,
|
223
|
+
# the motor will be driven with the low external voltage. If you then remove
|
224
|
+
# the external connection, it will immediately be driven by the high
|
225
|
+
# stack voltage.
|
226
|
+
def get_external_input_voltage
|
227
|
+
send_request(FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE, [], '', 2, 'S')
|
228
|
+
end
|
229
|
+
|
230
|
+
# Returns the current consumption of the motor in mA.
|
231
|
+
def get_current_consumption
|
232
|
+
send_request(FUNCTION_GET_CURRENT_CONSUMPTION, [], '', 2, 'S')
|
233
|
+
end
|
234
|
+
|
235
|
+
# Enables the driver chip. The driver parameters can be configured (velocity,
|
236
|
+
# acceleration, etc) before it is enabled.
|
237
|
+
def enable
|
238
|
+
send_request(FUNCTION_ENABLE, [], '', 0, '')
|
239
|
+
end
|
240
|
+
|
241
|
+
# Disables the driver chip. The configurations are kept (velocity,
|
242
|
+
# acceleration, etc) but the motor is not driven until it is enabled again.
|
243
|
+
def disable
|
244
|
+
send_request(FUNCTION_DISABLE, [], '', 0, '')
|
245
|
+
end
|
246
|
+
|
247
|
+
# Returns *true* if the driver chip is enabled, *false* otherwise.
|
248
|
+
def is_enabled
|
249
|
+
send_request(FUNCTION_IS_ENABLED, [], '', 1, '?')
|
250
|
+
end
|
251
|
+
|
252
|
+
# Sets the minimum voltage in mV, below which the CALLBACK_UNDER_VOLTAGE callback
|
253
|
+
# is triggered. The minimum possible value that works with the DC Brick is 5V.
|
254
|
+
# You can use this function to detect the discharge of a battery that is used
|
255
|
+
# to drive the motor. If you have a fixed power supply, you likely do not need
|
256
|
+
# this functionality.
|
257
|
+
#
|
258
|
+
# The default value is 5V.
|
259
|
+
def set_minimum_voltage(voltage)
|
260
|
+
send_request(FUNCTION_SET_MINIMUM_VOLTAGE, [voltage], 'S', 0, '')
|
261
|
+
end
|
262
|
+
|
263
|
+
# Returns the minimum voltage as set by BrickDC#set_minimum_voltage
|
264
|
+
def get_minimum_voltage
|
265
|
+
send_request(FUNCTION_GET_MINIMUM_VOLTAGE, [], '', 2, 'S')
|
266
|
+
end
|
267
|
+
|
268
|
+
# Sets the drive mode. Possible modes are:
|
269
|
+
#
|
270
|
+
# * 0 = Drive/Brake
|
271
|
+
# * 1 = Drive/Coast
|
272
|
+
#
|
273
|
+
# These modes are different kinds of motor controls.
|
274
|
+
#
|
275
|
+
# In Drive/Brake mode, the motor is always either driving or braking. There
|
276
|
+
# is no freewheeling. Advantages are: A more linear correlation between
|
277
|
+
# PWM and velocity, more exact accelerations and the possibility to drive
|
278
|
+
# with slower velocities.
|
279
|
+
#
|
280
|
+
# In Drive/Coast mode, the motor is always either driving or freewheeling.
|
281
|
+
# Advantages are: Less current consumption and less demands on the motor and
|
282
|
+
# driver chip.
|
283
|
+
#
|
284
|
+
# The default value is 0 = Drive/Brake.
|
285
|
+
def set_drive_mode(mode)
|
286
|
+
send_request(FUNCTION_SET_DRIVE_MODE, [mode], 'C', 0, '')
|
287
|
+
end
|
288
|
+
|
289
|
+
# Returns the drive mode, as set by BrickDC#set_drive_mode.
|
290
|
+
def get_drive_mode
|
291
|
+
send_request(FUNCTION_GET_DRIVE_MODE, [], '', 1, 'C')
|
292
|
+
end
|
293
|
+
|
294
|
+
# Sets a period in ms with which the CALLBACK_CURRENT_VELOCITY callback is triggered.
|
295
|
+
# A period of 0 turns the callback off.
|
296
|
+
#
|
297
|
+
# The default value is 0.
|
298
|
+
def set_current_velocity_period(period)
|
299
|
+
send_request(FUNCTION_SET_CURRENT_VELOCITY_PERIOD, [period], 'S', 0, '')
|
300
|
+
end
|
301
|
+
|
302
|
+
# Returns the period as set by BrickDC#set_current_velocity_period.
|
303
|
+
def get_current_velocity_period
|
304
|
+
send_request(FUNCTION_GET_CURRENT_VELOCITY_PERIOD, [], '', 2, 'S')
|
305
|
+
end
|
306
|
+
|
307
|
+
# Returns the firmware and protocol version and the name of the Bricklet for a given port.
|
308
|
+
#
|
309
|
+
# This functions sole purpose is to allow automatic flashing of v1.x.y Bricklet plugins.
|
310
|
+
#
|
311
|
+
# .. versionadded:: 2.0.0~(Firmware)
|
312
|
+
def get_protocol1_bricklet_name(port)
|
313
|
+
send_request(FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, [port], 'k', 44, 'C C3 Z40')
|
314
|
+
end
|
315
|
+
|
316
|
+
# Returns the temperature in °C/10 as measured inside the microcontroller. The
|
317
|
+
# value returned is not the ambient temperature!
|
318
|
+
#
|
319
|
+
# The temperature is only proportional to the real temperature and it has an
|
320
|
+
# accuracy of +-15%. Practically it is only useful as an indicator for
|
321
|
+
# temperature changes.
|
322
|
+
#
|
323
|
+
# .. versionadded:: 1.1.3~(Firmware)
|
324
|
+
def get_chip_temperature
|
325
|
+
send_request(FUNCTION_GET_CHIP_TEMPERATURE, [], '', 2, 's')
|
326
|
+
end
|
327
|
+
|
328
|
+
# Calling this function will reset the Brick. Calling this function
|
329
|
+
# on a Brick inside of a stack will reset the whole stack.
|
330
|
+
#
|
331
|
+
# After a reset you have to create new device objects,
|
332
|
+
# calling functions on the existing ones will result in
|
333
|
+
# undefined behavior!
|
334
|
+
#
|
335
|
+
# .. versionadded:: 1.1.3~(Firmware)
|
336
|
+
def reset
|
337
|
+
send_request(FUNCTION_RESET, [], '', 0, '')
|
338
|
+
end
|
339
|
+
|
340
|
+
# Returns the UID, the UID where the Brick is connected to,
|
341
|
+
# the position, the hardware and firmware version as well as the
|
342
|
+
# device identifier.
|
343
|
+
#
|
344
|
+
# The position can be '0'-'8' (stack position).
|
345
|
+
#
|
346
|
+
# The device identifiers can be found :ref:`here <device_identifier>`.
|
347
|
+
#
|
348
|
+
# .. versionadded:: 2.0.0~(Firmware)
|
349
|
+
def get_identity
|
350
|
+
send_request(FUNCTION_GET_IDENTITY, [], '', 25, 'Z8 Z8 k C3 C3 S')
|
351
|
+
end
|
352
|
+
|
353
|
+
# Registers a callback with ID <tt>id</tt> to the block <tt>block</tt>.
|
354
|
+
def register_callback(id, &block)
|
355
|
+
callback = block
|
356
|
+
@registered_callbacks[id] = callback
|
357
|
+
end
|
358
|
+
end
|
359
|
+
end
|
@@ -0,0 +1,512 @@
|
|
1
|
+
# -*- ruby encoding: utf-8 -*-
|
2
|
+
#############################################################
|
3
|
+
# This file was automatically generated on 2013-05-16. #
|
4
|
+
# #
|
5
|
+
# Bindings Version 2.0.7 #
|
6
|
+
# #
|
7
|
+
# If you have a bugfix for this file and want to commit it, #
|
8
|
+
# please fix the bug in the generator. You can find a link #
|
9
|
+
# to the generator git on tinkerforge.com #
|
10
|
+
#############################################################
|
11
|
+
|
12
|
+
module Tinkerforge
|
13
|
+
# Device for sensing acceleration, magnetic field and angular velocity
|
14
|
+
class BrickIMU < Device
|
15
|
+
DEVICE_IDENTIFIER = 16 # :nodoc:
|
16
|
+
|
17
|
+
# This callback is triggered periodically with the period that is set by
|
18
|
+
# BrickIMU#set_acceleration_period. The parameters are the acceleration
|
19
|
+
# for the x, y and z axis.
|
20
|
+
CALLBACK_ACCELERATION = 31
|
21
|
+
|
22
|
+
# This callback is triggered periodically with the period that is set by
|
23
|
+
# BrickIMU#set_magnetic_field_period. The parameters are the magnetic field
|
24
|
+
# for the x, y and z axis.
|
25
|
+
CALLBACK_MAGNETIC_FIELD = 32
|
26
|
+
|
27
|
+
# This callback is triggered periodically with the period that is set by
|
28
|
+
# BrickIMU#set_angular_velocity_period. The parameters are the angular velocity
|
29
|
+
# for the x, y and z axis.
|
30
|
+
CALLBACK_ANGULAR_VELOCITY = 33
|
31
|
+
|
32
|
+
# This callback is triggered periodically with the period that is set by
|
33
|
+
# BrickIMU#set_all_data_period. The parameters are the acceleration,
|
34
|
+
# the magnetic field and the angular velocity for the x, y and z axis as
|
35
|
+
# well as the temperature of the IMU Brick.
|
36
|
+
CALLBACK_ALL_DATA = 34
|
37
|
+
|
38
|
+
# This callback is triggered periodically with the period that is set by
|
39
|
+
# BrickIMU#set_orientation_period. The parameters are the orientation
|
40
|
+
# (roll, pitch and yaw) of the IMU Brick in Euler angles. See
|
41
|
+
# BrickIMU#get_orientation for details.
|
42
|
+
CALLBACK_ORIENTATION = 35
|
43
|
+
|
44
|
+
# This callback is triggered periodically with the period that is set by
|
45
|
+
# BrickIMU#set_quaternion_period. The parameters are the orientation
|
46
|
+
# (x, y, z, w) of the IMU Brick in quaternions. See BrickIMU#get_quaternion
|
47
|
+
# for details.
|
48
|
+
CALLBACK_QUATERNION = 36
|
49
|
+
|
50
|
+
FUNCTION_GET_ACCELERATION = 1 # :nodoc:
|
51
|
+
FUNCTION_GET_MAGNETIC_FIELD = 2 # :nodoc:
|
52
|
+
FUNCTION_GET_ANGULAR_VELOCITY = 3 # :nodoc:
|
53
|
+
FUNCTION_GET_ALL_DATA = 4 # :nodoc:
|
54
|
+
FUNCTION_GET_ORIENTATION = 5 # :nodoc:
|
55
|
+
FUNCTION_GET_QUATERNION = 6 # :nodoc:
|
56
|
+
FUNCTION_GET_IMU_TEMPERATURE = 7 # :nodoc:
|
57
|
+
FUNCTION_LEDS_ON = 8 # :nodoc:
|
58
|
+
FUNCTION_LEDS_OFF = 9 # :nodoc:
|
59
|
+
FUNCTION_ARE_LEDS_ON = 10 # :nodoc:
|
60
|
+
FUNCTION_SET_ACCELERATION_RANGE = 11 # :nodoc:
|
61
|
+
FUNCTION_GET_ACCELERATION_RANGE = 12 # :nodoc:
|
62
|
+
FUNCTION_SET_MAGNETOMETER_RANGE = 13 # :nodoc:
|
63
|
+
FUNCTION_GET_MAGNETOMETER_RANGE = 14 # :nodoc:
|
64
|
+
FUNCTION_SET_CONVERGENCE_SPEED = 15 # :nodoc:
|
65
|
+
FUNCTION_GET_CONVERGENCE_SPEED = 16 # :nodoc:
|
66
|
+
FUNCTION_SET_CALIBRATION = 17 # :nodoc:
|
67
|
+
FUNCTION_GET_CALIBRATION = 18 # :nodoc:
|
68
|
+
FUNCTION_SET_ACCELERATION_PERIOD = 19 # :nodoc:
|
69
|
+
FUNCTION_GET_ACCELERATION_PERIOD = 20 # :nodoc:
|
70
|
+
FUNCTION_SET_MAGNETIC_FIELD_PERIOD = 21 # :nodoc:
|
71
|
+
FUNCTION_GET_MAGNETIC_FIELD_PERIOD = 22 # :nodoc:
|
72
|
+
FUNCTION_SET_ANGULAR_VELOCITY_PERIOD = 23 # :nodoc:
|
73
|
+
FUNCTION_GET_ANGULAR_VELOCITY_PERIOD = 24 # :nodoc:
|
74
|
+
FUNCTION_SET_ALL_DATA_PERIOD = 25 # :nodoc:
|
75
|
+
FUNCTION_GET_ALL_DATA_PERIOD = 26 # :nodoc:
|
76
|
+
FUNCTION_SET_ORIENTATION_PERIOD = 27 # :nodoc:
|
77
|
+
FUNCTION_GET_ORIENTATION_PERIOD = 28 # :nodoc:
|
78
|
+
FUNCTION_SET_QUATERNION_PERIOD = 29 # :nodoc:
|
79
|
+
FUNCTION_GET_QUATERNION_PERIOD = 30 # :nodoc:
|
80
|
+
FUNCTION_ORIENTATION_CALCULATION_ON = 37 # :nodoc:
|
81
|
+
FUNCTION_ORIENTATION_CALCULATION_OFF = 38 # :nodoc:
|
82
|
+
FUNCTION_IS_ORIENTATION_CALCULATION_ON = 39 # :nodoc:
|
83
|
+
FUNCTION_GET_PROTOCOL1_BRICKLET_NAME = 241 # :nodoc:
|
84
|
+
FUNCTION_GET_CHIP_TEMPERATURE = 242 # :nodoc:
|
85
|
+
FUNCTION_RESET = 243 # :nodoc:
|
86
|
+
FUNCTION_GET_IDENTITY = 255 # :nodoc:
|
87
|
+
|
88
|
+
CALIBRATION_TYPE_ACCELEROMETER_GAIN = 0 # :nodoc:
|
89
|
+
CALIBRATION_TYPE_ACCELEROMETER_BIAS = 1 # :nodoc:
|
90
|
+
CALIBRATION_TYPE_MAGNETOMETER_GAIN = 2 # :nodoc:
|
91
|
+
CALIBRATION_TYPE_MAGNETOMETER_BIAS = 3 # :nodoc:
|
92
|
+
CALIBRATION_TYPE_GYROSCOPE_GAIN = 4 # :nodoc:
|
93
|
+
CALIBRATION_TYPE_GYROSCOPE_BIAS = 5 # :nodoc:
|
94
|
+
|
95
|
+
# Creates an object with the unique device ID <tt>uid</tt> and adds it to
|
96
|
+
# the IP Connection <tt>ipcon</tt>.
|
97
|
+
def initialize(uid, ipcon)
|
98
|
+
super uid, ipcon
|
99
|
+
|
100
|
+
@api_version = [2, 0, 1]
|
101
|
+
|
102
|
+
@response_expected[FUNCTION_GET_ACCELERATION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
103
|
+
@response_expected[FUNCTION_GET_MAGNETIC_FIELD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
104
|
+
@response_expected[FUNCTION_GET_ANGULAR_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
105
|
+
@response_expected[FUNCTION_GET_ALL_DATA] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
106
|
+
@response_expected[FUNCTION_GET_ORIENTATION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
107
|
+
@response_expected[FUNCTION_GET_QUATERNION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
108
|
+
@response_expected[FUNCTION_GET_IMU_TEMPERATURE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
109
|
+
@response_expected[FUNCTION_LEDS_ON] = RESPONSE_EXPECTED_FALSE
|
110
|
+
@response_expected[FUNCTION_LEDS_OFF] = RESPONSE_EXPECTED_FALSE
|
111
|
+
@response_expected[FUNCTION_ARE_LEDS_ON] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
112
|
+
@response_expected[FUNCTION_SET_ACCELERATION_RANGE] = RESPONSE_EXPECTED_FALSE
|
113
|
+
@response_expected[FUNCTION_GET_ACCELERATION_RANGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
114
|
+
@response_expected[FUNCTION_SET_MAGNETOMETER_RANGE] = RESPONSE_EXPECTED_FALSE
|
115
|
+
@response_expected[FUNCTION_GET_MAGNETOMETER_RANGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
116
|
+
@response_expected[FUNCTION_SET_CONVERGENCE_SPEED] = RESPONSE_EXPECTED_FALSE
|
117
|
+
@response_expected[FUNCTION_GET_CONVERGENCE_SPEED] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
118
|
+
@response_expected[FUNCTION_SET_CALIBRATION] = RESPONSE_EXPECTED_FALSE
|
119
|
+
@response_expected[FUNCTION_GET_CALIBRATION] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
120
|
+
@response_expected[FUNCTION_SET_ACCELERATION_PERIOD] = RESPONSE_EXPECTED_TRUE
|
121
|
+
@response_expected[FUNCTION_GET_ACCELERATION_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
122
|
+
@response_expected[FUNCTION_SET_MAGNETIC_FIELD_PERIOD] = RESPONSE_EXPECTED_TRUE
|
123
|
+
@response_expected[FUNCTION_GET_MAGNETIC_FIELD_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
124
|
+
@response_expected[FUNCTION_SET_ANGULAR_VELOCITY_PERIOD] = RESPONSE_EXPECTED_TRUE
|
125
|
+
@response_expected[FUNCTION_GET_ANGULAR_VELOCITY_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
126
|
+
@response_expected[FUNCTION_SET_ALL_DATA_PERIOD] = RESPONSE_EXPECTED_TRUE
|
127
|
+
@response_expected[FUNCTION_GET_ALL_DATA_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
128
|
+
@response_expected[FUNCTION_SET_ORIENTATION_PERIOD] = RESPONSE_EXPECTED_TRUE
|
129
|
+
@response_expected[FUNCTION_GET_ORIENTATION_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
130
|
+
@response_expected[FUNCTION_SET_QUATERNION_PERIOD] = RESPONSE_EXPECTED_TRUE
|
131
|
+
@response_expected[FUNCTION_GET_QUATERNION_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
132
|
+
@response_expected[CALLBACK_ACCELERATION] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
133
|
+
@response_expected[CALLBACK_MAGNETIC_FIELD] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
134
|
+
@response_expected[CALLBACK_ANGULAR_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
135
|
+
@response_expected[CALLBACK_ALL_DATA] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
136
|
+
@response_expected[CALLBACK_ORIENTATION] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
137
|
+
@response_expected[CALLBACK_QUATERNION] = RESPONSE_EXPECTED_ALWAYS_FALSE
|
138
|
+
@response_expected[FUNCTION_ORIENTATION_CALCULATION_ON] = RESPONSE_EXPECTED_FALSE
|
139
|
+
@response_expected[FUNCTION_ORIENTATION_CALCULATION_OFF] = RESPONSE_EXPECTED_FALSE
|
140
|
+
@response_expected[FUNCTION_IS_ORIENTATION_CALCULATION_ON] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
141
|
+
@response_expected[FUNCTION_GET_PROTOCOL1_BRICKLET_NAME] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
142
|
+
@response_expected[FUNCTION_GET_CHIP_TEMPERATURE] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
143
|
+
@response_expected[FUNCTION_RESET] = RESPONSE_EXPECTED_FALSE
|
144
|
+
@response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
|
145
|
+
|
146
|
+
@callback_formats[CALLBACK_ACCELERATION] = 's s s'
|
147
|
+
@callback_formats[CALLBACK_MAGNETIC_FIELD] = 's s s'
|
148
|
+
@callback_formats[CALLBACK_ANGULAR_VELOCITY] = 's s s'
|
149
|
+
@callback_formats[CALLBACK_ALL_DATA] = 's s s s s s s s s s'
|
150
|
+
@callback_formats[CALLBACK_ORIENTATION] = 's s s'
|
151
|
+
@callback_formats[CALLBACK_QUATERNION] = 'e e e e'
|
152
|
+
end
|
153
|
+
|
154
|
+
# Returns the calibrated acceleration from the accelerometer for the
|
155
|
+
# x, y and z axis in mG (G/1000, 1G = 9.80605m/s²).
|
156
|
+
#
|
157
|
+
# If you want to get the acceleration periodically, it is recommended
|
158
|
+
# to use the callback CALLBACK_ACCELERATION and set the period with
|
159
|
+
# BrickIMU#set_acceleration_period.
|
160
|
+
def get_acceleration
|
161
|
+
send_request(FUNCTION_GET_ACCELERATION, [], '', 6, 's s s')
|
162
|
+
end
|
163
|
+
|
164
|
+
# Returns the calibrated magnetic field from the magnetometer for the
|
165
|
+
# x, y and z axis in mG (Milligauss or Nanotesla).
|
166
|
+
#
|
167
|
+
# If you want to get the magnetic field periodically, it is recommended
|
168
|
+
# to use the callback CALLBACK_MAGNETIC_FIELD and set the period with
|
169
|
+
# BrickIMU#set_magnetic_field_period.
|
170
|
+
def get_magnetic_field
|
171
|
+
send_request(FUNCTION_GET_MAGNETIC_FIELD, [], '', 6, 's s s')
|
172
|
+
end
|
173
|
+
|
174
|
+
# Returns the calibrated angular velocity from the gyroscope for the
|
175
|
+
# x, y and z axis in °/17.5s (you have to divide by 17.5 to
|
176
|
+
# get the value in °/s).
|
177
|
+
#
|
178
|
+
# If you want to get the angular velocity periodically, it is recommended
|
179
|
+
# to use the callback CALLBACK_ANGULAR_VELOCITY and set the period with
|
180
|
+
# BrickIMU#set_angular_velocity_period.
|
181
|
+
def get_angular_velocity
|
182
|
+
send_request(FUNCTION_GET_ANGULAR_VELOCITY, [], '', 6, 's s s')
|
183
|
+
end
|
184
|
+
|
185
|
+
# Returns the data from BrickIMU#get_acceleration, BrickIMU#get_magnetic_field
|
186
|
+
# and BrickIMU#get_angular_velocity as well as the temperature of the IMU Brick.
|
187
|
+
#
|
188
|
+
# The temperature is given in °C/100.
|
189
|
+
#
|
190
|
+
# If you want to get the data periodically, it is recommended
|
191
|
+
# to use the callback CALLBACK_ALL_DATA and set the period with
|
192
|
+
# BrickIMU#set_all_data_period.
|
193
|
+
def get_all_data
|
194
|
+
send_request(FUNCTION_GET_ALL_DATA, [], '', 20, 's s s s s s s s s s')
|
195
|
+
end
|
196
|
+
|
197
|
+
# Returns the current orientation (roll, pitch, yaw) of the IMU Brick as Euler
|
198
|
+
# angles in one-hundredth degree. Note that Euler angles always experience a
|
199
|
+
# `gimbal lock <http://en.wikipedia.org/wiki/Gimbal_lock>`__.
|
200
|
+
#
|
201
|
+
# We recommend that you use quaternions instead.
|
202
|
+
#
|
203
|
+
# The order to sequence in which the orientation values should be applied is
|
204
|
+
# roll, yaw, pitch.
|
205
|
+
#
|
206
|
+
# If you want to get the orientation periodically, it is recommended
|
207
|
+
# to use the callback CALLBACK_ORIENTATION and set the period with
|
208
|
+
# BrickIMU#set_orientation_period.
|
209
|
+
def get_orientation
|
210
|
+
send_request(FUNCTION_GET_ORIENTATION, [], '', 6, 's s s')
|
211
|
+
end
|
212
|
+
|
213
|
+
# Returns the current orientation (x, y, z, w) of the IMU as
|
214
|
+
# `quaternions <http://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation>`__.
|
215
|
+
#
|
216
|
+
# You can go from quaternions to Euler angles with the following formula::
|
217
|
+
#
|
218
|
+
# roll = atan2(2*y*w - 2*x*z, 1 - 2*y*y - 2*z*z)
|
219
|
+
# pitch = atan2(2*x*w - 2*y*z, 1 - 2*x*x - 2*z*z)
|
220
|
+
# yaw = asin(2*x*y + 2*z*w)
|
221
|
+
#
|
222
|
+
# This process is not reversible, because of the
|
223
|
+
# `gimbal lock <http://en.wikipedia.org/wiki/Gimbal_lock>`__.
|
224
|
+
#
|
225
|
+
# Converting the quaternions to an OpenGL transformation matrix is
|
226
|
+
# possible with the following formula::
|
227
|
+
#
|
228
|
+
# matrix = [[1 - 2*(y*y + z*z), 2*(x*y - w*z), 2*(x*z + w*y), 0],
|
229
|
+
# [ 2*(x*y + w*z), 1 - 2*(x*x + z*z), 2*(y*z - w*x), 0],
|
230
|
+
# [ 2*(x*z - w*y), 2*(y*z + w*x), 1 - 2*(x*x + y*y), 0],
|
231
|
+
# [ 0, 0, 0, 1]]
|
232
|
+
#
|
233
|
+
# If you want to get the quaternions periodically, it is recommended
|
234
|
+
# to use the callback CALLBACK_QUATERNION and set the period with
|
235
|
+
# BrickIMU#set_quaternion_period.
|
236
|
+
def get_quaternion
|
237
|
+
send_request(FUNCTION_GET_QUATERNION, [], '', 16, 'e e e e')
|
238
|
+
end
|
239
|
+
|
240
|
+
# Returns the temperature of the IMU Brick. The temperature is given in
|
241
|
+
# °C/100.
|
242
|
+
def get_imu_temperature
|
243
|
+
send_request(FUNCTION_GET_IMU_TEMPERATURE, [], '', 2, 's')
|
244
|
+
end
|
245
|
+
|
246
|
+
# Turns the orientation and direction LEDs of the IMU Brick on.
|
247
|
+
def leds_on
|
248
|
+
send_request(FUNCTION_LEDS_ON, [], '', 0, '')
|
249
|
+
end
|
250
|
+
|
251
|
+
# Turns the orientation and direction LEDs of the IMU Brick off.
|
252
|
+
def leds_off
|
253
|
+
send_request(FUNCTION_LEDS_OFF, [], '', 0, '')
|
254
|
+
end
|
255
|
+
|
256
|
+
# Returns *true* if the orientation and direction LEDs of the IMU Brick
|
257
|
+
# are on, *false* otherwise.
|
258
|
+
def are_leds_on
|
259
|
+
send_request(FUNCTION_ARE_LEDS_ON, [], '', 1, '?')
|
260
|
+
end
|
261
|
+
|
262
|
+
# Not implemented yet.
|
263
|
+
def set_acceleration_range(range)
|
264
|
+
send_request(FUNCTION_SET_ACCELERATION_RANGE, [range], 'C', 0, '')
|
265
|
+
end
|
266
|
+
|
267
|
+
# Not implemented yet.
|
268
|
+
def get_acceleration_range
|
269
|
+
send_request(FUNCTION_GET_ACCELERATION_RANGE, [], '', 1, 'C')
|
270
|
+
end
|
271
|
+
|
272
|
+
# Not implemented yet.
|
273
|
+
def set_magnetometer_range(range)
|
274
|
+
send_request(FUNCTION_SET_MAGNETOMETER_RANGE, [range], 'C', 0, '')
|
275
|
+
end
|
276
|
+
|
277
|
+
# Not implemented yet.
|
278
|
+
def get_magnetometer_range
|
279
|
+
send_request(FUNCTION_GET_MAGNETOMETER_RANGE, [], '', 1, 'C')
|
280
|
+
end
|
281
|
+
|
282
|
+
# Sets the convergence speed of the IMU Brick in °/s. The convergence speed
|
283
|
+
# determines how the different sensor measurements are fused.
|
284
|
+
#
|
285
|
+
# If the orientation of the IMU Brick is off by 10° and the convergence speed is
|
286
|
+
# set to 20°/s, it will take 0.5s until the orientation is corrected. However,
|
287
|
+
# if the correct orientation is reached and the convergence speed is too high,
|
288
|
+
# the orientation will fluctuate with the fluctuations of the accelerometer and
|
289
|
+
# the magnetometer.
|
290
|
+
#
|
291
|
+
# If you set the convergence speed to 0, practically only the gyroscope is used
|
292
|
+
# to calculate the orientation. This gives very smooth movements, but errors of the
|
293
|
+
# gyroscope will not be corrected. If you set the convergence speed to something
|
294
|
+
# above 500, practically only the magnetometer and the accelerometer are used to
|
295
|
+
# calculate the orientation. In this case the movements are abrupt and the values
|
296
|
+
# will fluctuate, but there won't be any errors that accumulate over time.
|
297
|
+
#
|
298
|
+
# In an application with high angular velocities, we recommend a high convergence
|
299
|
+
# speed, so the errors of the gyroscope can be corrected fast. In applications with
|
300
|
+
# only slow movements we recommend a low convergence speed. You can change the
|
301
|
+
# convergence speed on the fly. So it is possible (and recommended) to increase
|
302
|
+
# the convergence speed before an abrupt movement and decrease it afterwards
|
303
|
+
# again.
|
304
|
+
#
|
305
|
+
# You might want to play around with the convergence speed in the Brick Viewer to
|
306
|
+
# get a feeling for a good value for your application.
|
307
|
+
#
|
308
|
+
# The default value is 30.
|
309
|
+
def set_convergence_speed(speed)
|
310
|
+
send_request(FUNCTION_SET_CONVERGENCE_SPEED, [speed], 'S', 0, '')
|
311
|
+
end
|
312
|
+
|
313
|
+
# Returns the convergence speed as set by BrickIMU#set_convergence_speed.
|
314
|
+
def get_convergence_speed
|
315
|
+
send_request(FUNCTION_GET_CONVERGENCE_SPEED, [], '', 2, 'S')
|
316
|
+
end
|
317
|
+
|
318
|
+
# There are several different types that can be calibrated:
|
319
|
+
#
|
320
|
+
# "Type", "Description", "Values"
|
321
|
+
#
|
322
|
+
# "0", "Accelerometer Gain", "[mul x, mul y, mul z, div x, div y, div z, 0, 0, 0, 0]"
|
323
|
+
# "1", "Accelerometer Bias", "[bias x, bias y, bias z, 0, 0, 0, 0, 0, 0, 0]"
|
324
|
+
# "2", "Magnetometer Gain", "[mul x, mul y, mul z, div x, div y, div z, 0, 0, 0, 0]"
|
325
|
+
# "3", "Magnetometer Bias", "[bias x, bias y, bias z, 0, 0, 0, 0, 0, 0, 0]"
|
326
|
+
# "4", "Gyroscope Gain", "[mul x, mul y, mul z, div x, div y, div z, 0, 0, 0, 0]"
|
327
|
+
# "5", "Gyroscope Bias", "[bias xl, bias yl, bias zl, temp l, bias xh, bias yh, bias zh, temp h, 0, 0]"
|
328
|
+
#
|
329
|
+
# The calibration via gain and bias is done with the following formula::
|
330
|
+
#
|
331
|
+
# new_value = (bias + orig_value) * gain_mul / gain_div
|
332
|
+
#
|
333
|
+
# If you really want to write your own calibration software, please keep
|
334
|
+
# in mind that you first have to undo the old calibration (set bias to 0 and
|
335
|
+
# gain to 1/1) and that you have to average over several thousand values
|
336
|
+
# to obtain a usable result in the end.
|
337
|
+
#
|
338
|
+
# The gyroscope bias is highly dependent on the temperature, so you have to
|
339
|
+
# calibrate the bias two times with different temperatures. The values xl, yl, zl
|
340
|
+
# and temp l are the bias for x, y, z and the corresponding temperature for a
|
341
|
+
# low temperature. The values xh, yh, zh and temp h are the same for a high
|
342
|
+
# temperatures. The temperature difference should be at least 5°C. If you have
|
343
|
+
# a temperature where the IMU Brick is mostly used, you should use this
|
344
|
+
# temperature for one of the sampling points.
|
345
|
+
#
|
346
|
+
# .. note::
|
347
|
+
# We highly recommend that you use the Brick Viewer to calibrate your
|
348
|
+
# IMU Brick.
|
349
|
+
def set_calibration(typ, data)
|
350
|
+
send_request(FUNCTION_SET_CALIBRATION, [typ, data], 'C s10', 0, '')
|
351
|
+
end
|
352
|
+
|
353
|
+
# Returns the calibration for a given type as set by BrickIMU#set_calibration.
|
354
|
+
def get_calibration(typ)
|
355
|
+
send_request(FUNCTION_GET_CALIBRATION, [typ], 'C', 20, 's10')
|
356
|
+
end
|
357
|
+
|
358
|
+
# Sets the period in ms with which the CALLBACK_ACCELERATION callback is triggered
|
359
|
+
# periodically. A value of 0 turns the callback off.
|
360
|
+
#
|
361
|
+
# The default value is 0.
|
362
|
+
def set_acceleration_period(period)
|
363
|
+
send_request(FUNCTION_SET_ACCELERATION_PERIOD, [period], 'L', 0, '')
|
364
|
+
end
|
365
|
+
|
366
|
+
# Returns the period as set by BrickIMU#set_acceleration_period.
|
367
|
+
def get_acceleration_period
|
368
|
+
send_request(FUNCTION_GET_ACCELERATION_PERIOD, [], '', 4, 'L')
|
369
|
+
end
|
370
|
+
|
371
|
+
# Sets the period in ms with which the CALLBACK_MAGNETIC_FIELD callback is triggered
|
372
|
+
# periodically. A value of 0 turns the callback off.
|
373
|
+
def set_magnetic_field_period(period)
|
374
|
+
send_request(FUNCTION_SET_MAGNETIC_FIELD_PERIOD, [period], 'L', 0, '')
|
375
|
+
end
|
376
|
+
|
377
|
+
# Returns the period as set by BrickIMU#set_magnetic_field_period.
|
378
|
+
def get_magnetic_field_period
|
379
|
+
send_request(FUNCTION_GET_MAGNETIC_FIELD_PERIOD, [], '', 4, 'L')
|
380
|
+
end
|
381
|
+
|
382
|
+
# Sets the period in ms with which the CALLBACK_ANGULAR_VELOCITY callback is triggered
|
383
|
+
# periodically. A value of 0 turns the callback off.
|
384
|
+
def set_angular_velocity_period(period)
|
385
|
+
send_request(FUNCTION_SET_ANGULAR_VELOCITY_PERIOD, [period], 'L', 0, '')
|
386
|
+
end
|
387
|
+
|
388
|
+
# Returns the period as set by BrickIMU#set_angular_velocity_period.
|
389
|
+
def get_angular_velocity_period
|
390
|
+
send_request(FUNCTION_GET_ANGULAR_VELOCITY_PERIOD, [], '', 4, 'L')
|
391
|
+
end
|
392
|
+
|
393
|
+
# Sets the period in ms with which the CALLBACK_ALL_DATA callback is triggered
|
394
|
+
# periodically. A value of 0 turns the callback off.
|
395
|
+
def set_all_data_period(period)
|
396
|
+
send_request(FUNCTION_SET_ALL_DATA_PERIOD, [period], 'L', 0, '')
|
397
|
+
end
|
398
|
+
|
399
|
+
# Returns the period as set by BrickIMU#set_all_data_period.
|
400
|
+
def get_all_data_period
|
401
|
+
send_request(FUNCTION_GET_ALL_DATA_PERIOD, [], '', 4, 'L')
|
402
|
+
end
|
403
|
+
|
404
|
+
# Sets the period in ms with which the CALLBACK_ORIENTATION callback is triggered
|
405
|
+
# periodically. A value of 0 turns the callback off.
|
406
|
+
def set_orientation_period(period)
|
407
|
+
send_request(FUNCTION_SET_ORIENTATION_PERIOD, [period], 'L', 0, '')
|
408
|
+
end
|
409
|
+
|
410
|
+
# Returns the period as set by BrickIMU#set_orientation_period.
|
411
|
+
def get_orientation_period
|
412
|
+
send_request(FUNCTION_GET_ORIENTATION_PERIOD, [], '', 4, 'L')
|
413
|
+
end
|
414
|
+
|
415
|
+
# Sets the period in ms with which the CALLBACK_QUATERNION callback is triggered
|
416
|
+
# periodically. A value of 0 turns the callback off.
|
417
|
+
def set_quaternion_period(period)
|
418
|
+
send_request(FUNCTION_SET_QUATERNION_PERIOD, [period], 'L', 0, '')
|
419
|
+
end
|
420
|
+
|
421
|
+
# Returns the period as set by BrickIMU#set_quaternion_period.
|
422
|
+
def get_quaternion_period
|
423
|
+
send_request(FUNCTION_GET_QUATERNION_PERIOD, [], '', 4, 'L')
|
424
|
+
end
|
425
|
+
|
426
|
+
# Turns the orientation calculation of the IMU Brick on.
|
427
|
+
#
|
428
|
+
# As default the calculation is on.
|
429
|
+
#
|
430
|
+
# .. versionadded:: 2.0.2~(Firmware)
|
431
|
+
def orientation_calculation_on
|
432
|
+
send_request(FUNCTION_ORIENTATION_CALCULATION_ON, [], '', 0, '')
|
433
|
+
end
|
434
|
+
|
435
|
+
# Turns the orientation calculation of the IMU Brick off.
|
436
|
+
#
|
437
|
+
# If the calculation is off, BrickIMU#get_orientation will return
|
438
|
+
# the last calculated value until the calculation is turned on again.
|
439
|
+
#
|
440
|
+
# The trigonometric functions that are needed to calculate the orientation
|
441
|
+
# are very expensive. We recommend to turn the orientation calculation
|
442
|
+
# off if the orientation is not needed, to free calculation time for the
|
443
|
+
# sensor fusion algorithm.
|
444
|
+
#
|
445
|
+
# As default the calculation is on.
|
446
|
+
#
|
447
|
+
# .. versionadded:: 2.0.2~(Firmware)
|
448
|
+
def orientation_calculation_off
|
449
|
+
send_request(FUNCTION_ORIENTATION_CALCULATION_OFF, [], '', 0, '')
|
450
|
+
end
|
451
|
+
|
452
|
+
# Returns *true* if the orientation calculation of the IMU Brick
|
453
|
+
# is on, *false* otherwise.
|
454
|
+
#
|
455
|
+
# .. versionadded:: 2.0.2~(Firmware)
|
456
|
+
def is_orientation_calculation_on
|
457
|
+
send_request(FUNCTION_IS_ORIENTATION_CALCULATION_ON, [], '', 1, '?')
|
458
|
+
end
|
459
|
+
|
460
|
+
# Returns the firmware and protocol version and the name of the Bricklet for a given port.
|
461
|
+
#
|
462
|
+
# This functions sole purpose is to allow automatic flashing of v1.x.y Bricklet plugins.
|
463
|
+
#
|
464
|
+
# .. versionadded:: 2.0.0~(Firmware)
|
465
|
+
def get_protocol1_bricklet_name(port)
|
466
|
+
send_request(FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, [port], 'k', 44, 'C C3 Z40')
|
467
|
+
end
|
468
|
+
|
469
|
+
# Returns the temperature in °C/10 as measured inside the microcontroller. The
|
470
|
+
# value returned is not the ambient temperature!
|
471
|
+
#
|
472
|
+
# The temperature is only proportional to the real temperature and it has an
|
473
|
+
# accuracy of +-15%. Practically it is only useful as an indicator for
|
474
|
+
# temperature changes.
|
475
|
+
#
|
476
|
+
# .. versionadded:: 1.0.7~(Firmware)
|
477
|
+
def get_chip_temperature
|
478
|
+
send_request(FUNCTION_GET_CHIP_TEMPERATURE, [], '', 2, 's')
|
479
|
+
end
|
480
|
+
|
481
|
+
# Calling this function will reset the Brick. Calling this function
|
482
|
+
# on a Brick inside of a stack will reset the whole stack.
|
483
|
+
#
|
484
|
+
# After a reset you have to create new device objects,
|
485
|
+
# calling functions on the existing ones will result in
|
486
|
+
# undefined behavior!
|
487
|
+
#
|
488
|
+
# .. versionadded:: 1.0.7~(Firmware)
|
489
|
+
def reset
|
490
|
+
send_request(FUNCTION_RESET, [], '', 0, '')
|
491
|
+
end
|
492
|
+
|
493
|
+
# Returns the UID, the UID where the Brick is connected to,
|
494
|
+
# the position, the hardware and firmware version as well as the
|
495
|
+
# device identifier.
|
496
|
+
#
|
497
|
+
# The position can be '0'-'8' (stack position).
|
498
|
+
#
|
499
|
+
# The device identifiers can be found :ref:`here <device_identifier>`.
|
500
|
+
#
|
501
|
+
# .. versionadded:: 2.0.0~(Firmware)
|
502
|
+
def get_identity
|
503
|
+
send_request(FUNCTION_GET_IDENTITY, [], '', 25, 'Z8 Z8 k C3 C3 S')
|
504
|
+
end
|
505
|
+
|
506
|
+
# Registers a callback with ID <tt>id</tt> to the block <tt>block</tt>.
|
507
|
+
def register_callback(id, &block)
|
508
|
+
callback = block
|
509
|
+
@registered_callbacks[id] = callback
|
510
|
+
end
|
511
|
+
end
|
512
|
+
end
|