Class: Tinkerforge::BrickStepper

Inherits:
Device
  • Object
show all
Defined in:
lib/tinkerforge/brick_stepper.rb

Overview

Drives one bipolar stepper motor with up to 38V and 2.5A per phase

Constant Summary collapse

DEVICE_IDENTIFIER =

:nodoc:

15
DEVICE_DISPLAY_NAME =

:nodoc:

'Stepper Brick'
CALLBACK_UNDER_VOLTAGE =

This callback is triggered when the input voltage drops below the value set by BrickStepper#set_minimum_voltage. The parameter is the current voltage.

31
CALLBACK_POSITION_REACHED =

This callback is triggered when a position set by BrickStepper#set_steps or BrickStepper#set_target_position is reached.

.. note

Since we can’t get any feedback from the stepper motor, this only works if the acceleration (see BrickStepper#set_speed_ramping) is set smaller or equal to the maximum acceleration of the motor. Otherwise the motor will lag behind the control value and the callback will be triggered too early.

32
CALLBACK_ALL_DATA =

This callback is triggered periodically with the period that is set by BrickStepper#set_all_data_period. The parameters are: the current velocity, the current position, the remaining steps, the stack voltage, the external voltage and the current consumption of the stepper motor.

40
CALLBACK_NEW_STATE =

This callback is triggered whenever the Stepper Brick enters a new state. It returns the new state as well as the previous state.

41
FUNCTION_SET_MAX_VELOCITY =

:nodoc:

1
FUNCTION_GET_MAX_VELOCITY =

:nodoc:

2
FUNCTION_GET_CURRENT_VELOCITY =

:nodoc:

3
FUNCTION_SET_SPEED_RAMPING =

:nodoc:

4
FUNCTION_GET_SPEED_RAMPING =

:nodoc:

5
FUNCTION_FULL_BRAKE =

:nodoc:

6
FUNCTION_SET_CURRENT_POSITION =

:nodoc:

7
FUNCTION_GET_CURRENT_POSITION =

:nodoc:

8
FUNCTION_SET_TARGET_POSITION =

:nodoc:

9
FUNCTION_GET_TARGET_POSITION =

:nodoc:

10
FUNCTION_SET_STEPS =

:nodoc:

11
FUNCTION_GET_STEPS =

:nodoc:

12
FUNCTION_GET_REMAINING_STEPS =

:nodoc:

13
FUNCTION_SET_STEP_MODE =

:nodoc:

14
FUNCTION_GET_STEP_MODE =

:nodoc:

15
FUNCTION_DRIVE_FORWARD =

:nodoc:

16
FUNCTION_DRIVE_BACKWARD =

:nodoc:

17
FUNCTION_STOP =

:nodoc:

18
FUNCTION_GET_STACK_INPUT_VOLTAGE =

:nodoc:

19
FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE =

:nodoc:

20
FUNCTION_GET_CURRENT_CONSUMPTION =

:nodoc:

21
FUNCTION_SET_MOTOR_CURRENT =

:nodoc:

22
FUNCTION_GET_MOTOR_CURRENT =

:nodoc:

23
FUNCTION_ENABLE =

:nodoc:

24
FUNCTION_DISABLE =

:nodoc:

25
FUNCTION_IS_ENABLED =

:nodoc:

26
FUNCTION_SET_DECAY =

:nodoc:

27
FUNCTION_GET_DECAY =

:nodoc:

28
FUNCTION_SET_MINIMUM_VOLTAGE =

:nodoc:

29
FUNCTION_GET_MINIMUM_VOLTAGE =

:nodoc:

30
FUNCTION_SET_SYNC_RECT =

:nodoc:

33
FUNCTION_IS_SYNC_RECT =

:nodoc:

34
FUNCTION_SET_TIME_BASE =

:nodoc:

35
FUNCTION_GET_TIME_BASE =

:nodoc:

36
FUNCTION_GET_ALL_DATA =

:nodoc:

37
FUNCTION_SET_ALL_DATA_PERIOD =

:nodoc:

38
FUNCTION_GET_ALL_DATA_PERIOD =

:nodoc:

39
FUNCTION_SET_SPITFP_BAUDRATE_CONFIG =

:nodoc:

231
FUNCTION_GET_SPITFP_BAUDRATE_CONFIG =

:nodoc:

232
FUNCTION_GET_SEND_TIMEOUT_COUNT =

:nodoc:

233
FUNCTION_SET_SPITFP_BAUDRATE =

:nodoc:

234
FUNCTION_GET_SPITFP_BAUDRATE =

:nodoc:

235
FUNCTION_GET_SPITFP_ERROR_COUNT =

:nodoc:

237
FUNCTION_ENABLE_STATUS_LED =

:nodoc:

238
FUNCTION_DISABLE_STATUS_LED =

:nodoc:

239
FUNCTION_IS_STATUS_LED_ENABLED =

:nodoc:

240
FUNCTION_GET_PROTOCOL1_BRICKLET_NAME =

:nodoc:

241
FUNCTION_GET_CHIP_TEMPERATURE =

:nodoc:

242
FUNCTION_RESET =

:nodoc:

243
FUNCTION_WRITE_BRICKLET_PLUGIN =

:nodoc:

246
FUNCTION_READ_BRICKLET_PLUGIN =

:nodoc:

247
FUNCTION_GET_IDENTITY =

:nodoc:

255
STEP_MODE_FULL_STEP =

:nodoc:

1
STEP_MODE_HALF_STEP =

:nodoc:

2
STEP_MODE_QUARTER_STEP =

:nodoc:

4
STEP_MODE_EIGHTH_STEP =

:nodoc:

8
STATE_STOP =

:nodoc:

1
STATE_ACCELERATION =

:nodoc:

2
STATE_RUN =

:nodoc:

3
STATE_DEACCELERATION =

:nodoc:

4
STATE_DIRECTION_CHANGE_TO_FORWARD =

:nodoc:

5
STATE_DIRECTION_CHANGE_TO_BACKWARD =

:nodoc:

6
COMMUNICATION_METHOD_NONE =

:nodoc:

0
COMMUNICATION_METHOD_USB =

:nodoc:

1
COMMUNICATION_METHOD_SPI_STACK =

:nodoc:

2
COMMUNICATION_METHOD_CHIBI =

:nodoc:

3
COMMUNICATION_METHOD_RS485 =

:nodoc:

4
COMMUNICATION_METHOD_WIFI =

:nodoc:

5
COMMUNICATION_METHOD_ETHERNET =

:nodoc:

6
COMMUNICATION_METHOD_WIFI_V2 =

:nodoc:

7

Constants inherited from Device

Device::DEVICE_IDENTIFIER_CHECK_MATCH, Device::DEVICE_IDENTIFIER_CHECK_MISMATCH, Device::DEVICE_IDENTIFIER_CHECK_PENDING, Device::RESPONSE_EXPECTED_ALWAYS_TRUE, Device::RESPONSE_EXPECTED_FALSE, Device::RESPONSE_EXPECTED_INVALID_FUNCTION_ID, Device::RESPONSE_EXPECTED_TRUE

Instance Attribute Summary

Attributes inherited from Device

#callback_formats, #expected_response_function_id, #expected_response_sequence_number, #high_level_callbacks, #registered_callbacks, #replaced, #uid

Instance Method Summary collapse

Methods inherited from Device

#check_validity, #dequeue_response, #enqueue_response, #get_api_version, #get_response_expected, #send_request, #set_response_expected, #set_response_expected_all

Constructor Details

#initialize(uid, ipcon) ⇒ BrickStepper

Creates an object with the unique device ID uid and adds it to the IP Connection ipcon.



118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
 
# File 'lib/tinkerforge/brick_stepper.rb', line 118

def initialize(uid, ipcon)
  super uid, ipcon, DEVICE_IDENTIFIER, DEVICE_DISPLAY_NAME

  @api_version = [2, 0, 4]

  @response_expected[FUNCTION_SET_MAX_VELOCITY] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_MAX_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_CURRENT_VELOCITY] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_SPEED_RAMPING] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_SPEED_RAMPING] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_FULL_BRAKE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_SET_CURRENT_POSITION] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_CURRENT_POSITION] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_TARGET_POSITION] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_TARGET_POSITION] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_STEPS] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_STEPS] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_REMAINING_STEPS] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_STEP_MODE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_STEP_MODE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_DRIVE_FORWARD] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_DRIVE_BACKWARD] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_STOP] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_STACK_INPUT_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_CURRENT_CONSUMPTION] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_MOTOR_CURRENT] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_MOTOR_CURRENT] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_ENABLE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_DISABLE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_IS_ENABLED] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_DECAY] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_DECAY] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_MINIMUM_VOLTAGE] = RESPONSE_EXPECTED_TRUE
  @response_expected[FUNCTION_GET_MINIMUM_VOLTAGE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_SYNC_RECT] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_IS_SYNC_RECT] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_TIME_BASE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_TIME_BASE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_ALL_DATA] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_ALL_DATA_PERIOD] = RESPONSE_EXPECTED_TRUE
  @response_expected[FUNCTION_GET_ALL_DATA_PERIOD] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_SPITFP_BAUDRATE_CONFIG] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_SPITFP_BAUDRATE_CONFIG] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_SEND_TIMEOUT_COUNT] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_SET_SPITFP_BAUDRATE] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_GET_SPITFP_BAUDRATE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_SPITFP_ERROR_COUNT] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_ENABLE_STATUS_LED] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_DISABLE_STATUS_LED] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_IS_STATUS_LED_ENABLED] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_PROTOCOL1_BRICKLET_NAME] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_CHIP_TEMPERATURE] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_RESET] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_WRITE_BRICKLET_PLUGIN] = RESPONSE_EXPECTED_FALSE
  @response_expected[FUNCTION_READ_BRICKLET_PLUGIN] = RESPONSE_EXPECTED_ALWAYS_TRUE
  @response_expected[FUNCTION_GET_IDENTITY] = RESPONSE_EXPECTED_ALWAYS_TRUE

  @callback_formats[CALLBACK_UNDER_VOLTAGE] = [10, 'S']
  @callback_formats[CALLBACK_POSITION_REACHED] = [12, 'l']
  @callback_formats[CALLBACK_ALL_DATA] = [24, 'S l l S S S']
  @callback_formats[CALLBACK_NEW_STATE] = [10, 'C C']

  @ipcon.add_device self
end

Instance Method Details

#disable ⇒ Object

Disables the driver chip. The configurations are kept (maximum velocity, acceleration, etc) but the motor is not driven until it is enabled again.

.. warning

Disabling the driver chip while the motor is still turning can damage the driver chip. The motor should be stopped calling BrickStepper#stop function before disabling the motor power. The BrickStepper#stop function will not wait until the motor is actually stopped. You have to explicitly wait for the appropriate time after calling the BrickStepper#stop function before calling the BrickStepper#disable function.



434
435
436
437
438
 
# File 'lib/tinkerforge/brick_stepper.rb', line 434

def disable
  check_validity

  send_request FUNCTION_DISABLE, [], '', 8, ''
end

#disable_status_led ⇒ Object

Disables the status LED.

The status LED is the blue LED next to the USB connector. If enabled is is on and it flickers if data is transfered. If disabled it is always off.

The default state is enabled.

.. versionadded

2.3.1$nbsp;(Firmware)



694
695
696
697
698
 
# File 'lib/tinkerforge/brick_stepper.rb', line 694

def disable_status_led
  check_validity

  send_request FUNCTION_DISABLE_STATUS_LED, [], '', 8, ''
end

#drive_backward ⇒ Object

Drives the stepper motor backward until BrickStepper#drive_forward or BrickStepper#stop is triggered. The velocity, acceleration and deacceleration as set by BrickStepper#set_max_velocity and BrickStepper#set_speed_ramping will be used.



350
351
352
353
354
 
# File 'lib/tinkerforge/brick_stepper.rb', line 350

def drive_backward
  check_validity

  send_request FUNCTION_DRIVE_BACKWARD, [], '', 8, ''
end

#drive_forward ⇒ Object

Drives the stepper motor forward until BrickStepper#drive_backward or BrickStepper#stop is called. The velocity, acceleration and deacceleration as set by BrickStepper#set_max_velocity and BrickStepper#set_speed_ramping will be used.



341
342
343
344
345
 
# File 'lib/tinkerforge/brick_stepper.rb', line 341

def drive_forward
  check_validity

  send_request FUNCTION_DRIVE_FORWARD, [], '', 8, ''
end

#enable ⇒ Object

Enables the driver chip. The driver parameters can be configured (maximum velocity, acceleration, etc) before it is enabled.



418
419
420
421
422
 
# File 'lib/tinkerforge/brick_stepper.rb', line 418

def enable
  check_validity

  send_request FUNCTION_ENABLE, [], '', 8, ''
end

#enable_status_led ⇒ Object

Enables the status LED.

The status LED is the blue LED next to the USB connector. If enabled is is on and it flickers if data is transfered. If disabled it is always off.

The default state is enabled.

.. versionadded

2.3.1$nbsp;(Firmware)



680
681
682
683
684
 
# File 'lib/tinkerforge/brick_stepper.rb', line 680

def enable_status_led
  check_validity

  send_request FUNCTION_ENABLE_STATUS_LED, [], '', 8, ''
end

#full_brake ⇒ Object

Executes an active full brake.

.. warning

This function is for emergency purposes, where an immediate brake is necessary. Depending on the current velocity and the strength of the motor, a full brake can be quite violent.

Call BrickStepper#stop if you just want to stop the motor.



241
242
243
244
245
 
# File 'lib/tinkerforge/brick_stepper.rb', line 241

def full_brake
  check_validity

  send_request FUNCTION_FULL_BRAKE, [], '', 8, ''
end

#get_all_data ⇒ Object

Returns the following parameters: The current velocity, the current position, the remaining steps, the stack voltage, the external voltage and the current consumption of the stepper motor.

There is also a callback for this function, see CALLBACK_ALL_DATA callback.



553
554
555
556
557
 
# File 'lib/tinkerforge/brick_stepper.rb', line 553

def get_all_data
  check_validity

  send_request FUNCTION_GET_ALL_DATA, [], '', 24, 'S l l S S S'
end

#get_all_data_period ⇒ Object

Returns the period as set by BrickStepper#set_all_data_period.



568
569
570
571
572
 
# File 'lib/tinkerforge/brick_stepper.rb', line 568

def get_all_data_period
  check_validity

  send_request FUNCTION_GET_ALL_DATA_PERIOD, [], '', 12, 'L'
end

#get_chip_temperature ⇒ Object

Returns the temperature as measured inside the microcontroller. The value returned is not the ambient temperature!

The temperature is only proportional to the real temperature and it has an accuracy of ±15%. Practically it is only useful as an indicator for temperature changes.



726
727
728
729
730
 
# File 'lib/tinkerforge/brick_stepper.rb', line 726

def get_chip_temperature
  check_validity

  send_request FUNCTION_GET_CHIP_TEMPERATURE, [], '', 10, 's'
end

#get_current_consumption ⇒ Object

Returns the current consumption of the motor.



392
393
394
395
396
 
# File 'lib/tinkerforge/brick_stepper.rb', line 392

def get_current_consumption
  check_validity

  send_request FUNCTION_GET_CURRENT_CONSUMPTION, [], '', 10, 'S'
end

#get_current_position ⇒ Object

Returns the current position of the stepper motor in steps. On startup the position is 0. The steps are counted with all possible driving functions (BrickStepper#set_target_position, BrickStepper#set_steps, BrickStepper#drive_forward or BrickStepper#drive_backward). It also is possible to reset the steps to 0 or set them to any other desired value with BrickStepper#set_current_position.



261
262
263
264
265
 
# File 'lib/tinkerforge/brick_stepper.rb', line 261

def get_current_position
  check_validity

  send_request FUNCTION_GET_CURRENT_POSITION, [], '', 12, 'l'
end

#get_current_velocity ⇒ Object

Returns the current velocity of the stepper motor.



203
204
205
206
207
 
# File 'lib/tinkerforge/brick_stepper.rb', line 203

def get_current_velocity
  check_validity

  send_request FUNCTION_GET_CURRENT_VELOCITY, [], '', 10, 'S'
end

#get_decay ⇒ Object

Returns the decay mode as set by BrickStepper#set_decay.



479
480
481
482
483
 
# File 'lib/tinkerforge/brick_stepper.rb', line 479

def get_decay
  check_validity

  send_request FUNCTION_GET_DECAY, [], '', 10, 'S'
end

#get_external_input_voltage ⇒ Object

Returns the external input voltage. The external input voltage is given via the black power input connector on the Stepper Brick.

If there is an external input voltage and a stack input voltage, the motor will be driven by the external input voltage. If there is only a stack voltage present, the motor will be driven by this voltage.

.. warning

This means, if you have a high stack voltage and a low external voltage, the motor will be driven with the low external voltage. If you then remove the external connection, it will immediately be driven by the high stack voltage



385
386
387
388
389
 
# File 'lib/tinkerforge/brick_stepper.rb', line 385

def get_external_input_voltage
  check_validity

  send_request FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE, [], '', 10, 'S'
end

#get_identity ⇒ Object

Returns the UID, the UID where the Brick is connected to, the position, the hardware and firmware version as well as the device identifier.

The position is the position in the stack from ‘0’ (bottom) to ‘8’ (top).

The device identifier numbers can be found :ref:‘here <device_identifier>`. |device_identifier_constant|



774
775
776
 
# File 'lib/tinkerforge/brick_stepper.rb', line 774

def get_identity
  send_request FUNCTION_GET_IDENTITY, [], '', 33, 'Z8 Z8 k C3 C3 S'
end

#get_max_velocity ⇒ Object

Returns the velocity as set by BrickStepper#set_max_velocity.



196
197
198
199
200
 
# File 'lib/tinkerforge/brick_stepper.rb', line 196

def get_max_velocity
  check_validity

  send_request FUNCTION_GET_MAX_VELOCITY, [], '', 10, 'S'
end

#get_minimum_voltage ⇒ Object

Returns the minimum voltage as set by BrickStepper#set_minimum_voltage.



497
498
499
500
501
 
# File 'lib/tinkerforge/brick_stepper.rb', line 497

def get_minimum_voltage
  check_validity

  send_request FUNCTION_GET_MINIMUM_VOLTAGE, [], '', 10, 'S'
end

#get_motor_current ⇒ Object

Returns the current as set by BrickStepper#set_motor_current.



410
411
412
413
414
 
# File 'lib/tinkerforge/brick_stepper.rb', line 410

def get_motor_current
  check_validity

  send_request FUNCTION_GET_MOTOR_CURRENT, [], '', 10, 'S'
end

#get_protocol1_bricklet_name(port) ⇒ Object

Returns the firmware and protocol version and the name of the Bricklet for a given port.

This functions sole purpose is to allow automatic flashing of v1.x.y Bricklet plugins.



714
715
716
717
718
 
# File 'lib/tinkerforge/brick_stepper.rb', line 714

def get_protocol1_bricklet_name(port)
  check_validity

  send_request FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, [port], 'k', 52, 'C C3 Z40'
end

#get_remaining_steps ⇒ Object

Returns the remaining steps of the last call of BrickStepper#set_steps. For example, if BrickStepper#set_steps is called with 2000 and BrickStepper#get_remaining_steps is called after the motor has run for 500 steps, it will return 1500.



310
311
312
313
314
 
# File 'lib/tinkerforge/brick_stepper.rb', line 310

def get_remaining_steps
  check_validity

  send_request FUNCTION_GET_REMAINING_STEPS, [], '', 12, 'l'
end

#get_send_timeout_count(communication_method) ⇒ Object

Returns the timeout count for the different communication methods.

The methods 0-2 are available for all Bricks, 3-7 only for Master Bricks.

This function is mostly used for debugging during development, in normal operation the counters should nearly always stay at 0.

.. versionadded

2.3.4$nbsp;(Firmware)



617
618
619
620
621
 
# File 'lib/tinkerforge/brick_stepper.rb', line 617

def get_send_timeout_count(communication_method)
  check_validity

  send_request FUNCTION_GET_SEND_TIMEOUT_COUNT, [communication_method], 'C', 12, 'L'
end

#get_speed_ramping ⇒ Object

Returns the acceleration and deacceleration as set by BrickStepper#set_speed_ramping.



227
228
229
230
231
 
# File 'lib/tinkerforge/brick_stepper.rb', line 227

def get_speed_ramping
  check_validity

  send_request FUNCTION_GET_SPEED_RAMPING, [], '', 12, 'S S'
end

#get_spitfp_baudrate(bricklet_port) ⇒ Object

Returns the baudrate for a given Bricklet port, see BrickStepper#set_spitfp_baudrate.

.. versionadded

2.3.3$nbsp;(Firmware)



647
648
649
650
651
 
# File 'lib/tinkerforge/brick_stepper.rb', line 647

def get_spitfp_baudrate(bricklet_port)
  check_validity

  send_request FUNCTION_GET_SPITFP_BAUDRATE, [bricklet_port], 'k', 12, 'L'
end

#get_spitfp_baudrate_config ⇒ Object

Returns the baudrate config, see BrickStepper#set_spitfp_baudrate_config.

.. versionadded

2.3.6$nbsp;(Firmware)



603
604
605
606
607
 
# File 'lib/tinkerforge/brick_stepper.rb', line 603

def get_spitfp_baudrate_config
  check_validity

  send_request FUNCTION_GET_SPITFP_BAUDRATE_CONFIG, [], '', 13, '? L'
end

#get_spitfp_error_count(bricklet_port) ⇒ Object

Returns the error count for the communication between Brick and Bricklet.

The errors are divided into

  • ACK checksum errors,

  • message checksum errors,

  • framing errors and

  • overflow errors.

The errors counts are for errors that occur on the Brick side. All Bricklets have a similar function that returns the errors on the Bricklet side.

.. versionadded

2.3.3$nbsp;(Firmware)



666
667
668
669
670
 
# File 'lib/tinkerforge/brick_stepper.rb', line 666

def get_spitfp_error_count(bricklet_port)
  check_validity

  send_request FUNCTION_GET_SPITFP_ERROR_COUNT, [bricklet_port], 'k', 24, 'L L L L'
end

#get_stack_input_voltage ⇒ Object

Returns the stack input voltage. The stack input voltage is the voltage that is supplied via the stack, i.e. it is given by a Step-Down or Step-Up Power Supply.



367
368
369
370
371
 
# File 'lib/tinkerforge/brick_stepper.rb', line 367

def get_stack_input_voltage
  check_validity

  send_request FUNCTION_GET_STACK_INPUT_VOLTAGE, [], '', 10, 'S'
end

#get_step_mode ⇒ Object

Returns the step mode as set by BrickStepper#set_step_mode.



332
333
334
335
336
 
# File 'lib/tinkerforge/brick_stepper.rb', line 332

def get_step_mode
  check_validity

  send_request FUNCTION_GET_STEP_MODE, [], '', 9, 'C'
end

#get_steps ⇒ Object

Returns the last steps as set by BrickStepper#set_steps.



300
301
302
303
304
 
# File 'lib/tinkerforge/brick_stepper.rb', line 300

def get_steps
  check_validity

  send_request FUNCTION_GET_STEPS, [], '', 12, 'l'
end

#get_target_position ⇒ Object

Returns the last target position as set by BrickStepper#set_target_position.



283
284
285
286
287
 
# File 'lib/tinkerforge/brick_stepper.rb', line 283

def get_target_position
  check_validity

  send_request FUNCTION_GET_TARGET_POSITION, [], '', 12, 'l'
end

#get_time_base ⇒ Object

Returns the time base as set by BrickStepper#set_time_base.



542
543
544
545
546
 
# File 'lib/tinkerforge/brick_stepper.rb', line 542

def get_time_base
  check_validity

  send_request FUNCTION_GET_TIME_BASE, [], '', 12, 'L'
end

#is_enabled ⇒ Object

Returns true if the driver chip is enabled, false otherwise.



441
442
443
444
445
 
# File 'lib/tinkerforge/brick_stepper.rb', line 441

def is_enabled
  check_validity

  send_request FUNCTION_IS_ENABLED, [], '', 9, '?'
end

#is_status_led_enabled ⇒ Object

Returns true if the status LED is enabled, false otherwise.

.. versionadded

2.3.1$nbsp;(Firmware)



703
704
705
706
707
 
# File 'lib/tinkerforge/brick_stepper.rb', line 703

def is_status_led_enabled
  check_validity

  send_request FUNCTION_IS_STATUS_LED_ENABLED, [], '', 9, '?'
end

#is_sync_rect ⇒ Object

Returns true if synchronous rectification is enabled, false otherwise.



524
525
526
527
528
 
# File 'lib/tinkerforge/brick_stepper.rb', line 524

def is_sync_rect
  check_validity

  send_request FUNCTION_IS_SYNC_RECT, [], '', 9, '?'
end

#read_bricklet_plugin(port, offset) ⇒ Object

Reads 32 bytes of firmware from the bricklet attached at the given port. The bytes are read starting at the position offset * 32.

This function is used by Brick Viewer during flashing. It should not be necessary to call it in a normal user program.



760
761
762
763
764
 
# File 'lib/tinkerforge/brick_stepper.rb', line 760

def read_bricklet_plugin(port, offset)
  check_validity

  send_request FUNCTION_READ_BRICKLET_PLUGIN, [port, offset], 'k C', 40, 'C32'
end

#register_callback(id, &block) ⇒ Object

Registers a callback with ID id to the block block.



779
780
781
782
 
# File 'lib/tinkerforge/brick_stepper.rb', line 779

def register_callback(id, &block)
  callback = block
  @registered_callbacks[id] = callback
end

#reset ⇒ Object

Calling this function will reset the Brick. Calling this function on a Brick inside of a stack will reset the whole stack.

After a reset you have to create new device objects, calling functions on the existing ones will result in undefined behavior!



738
739
740
741
742
 
# File 'lib/tinkerforge/brick_stepper.rb', line 738

def reset
  check_validity

  send_request FUNCTION_RESET, [], '', 8, ''
end

#set_all_data_period(period) ⇒ Object

Sets the period with which the CALLBACK_ALL_DATA callback is triggered periodically. A value of 0 turns the callback off.



561
562
563
564
565
 
# File 'lib/tinkerforge/brick_stepper.rb', line 561

def set_all_data_period(period)
  check_validity

  send_request FUNCTION_SET_ALL_DATA_PERIOD, [period], 'L', 8, ''
end

#set_current_position(position) ⇒ Object

Sets the current steps of the internal step counter. This can be used to set the current position to 0 when some kind of starting position is reached (e.g. when a CNC machine reaches a corner).



250
251
252
253
254
 
# File 'lib/tinkerforge/brick_stepper.rb', line 250

def set_current_position(position)
  check_validity

  send_request FUNCTION_SET_CURRENT_POSITION, [position], 'l', 8, ''
end

#set_decay(decay) ⇒ Object

Sets the decay mode of the stepper motor. A value of 0 sets the fast decay mode, a value of 65535 sets the slow decay mode and a value in between sets the mixed decay mode.

Changing the decay mode is only possible if synchronous rectification is enabled (see BrickStepper#set_sync_rect).

For a good explanation of the different decay modes see ‘this <ebldc.com/?p=86/>`__ blog post by Avayan.

A good decay mode is unfortunately different for every motor. The best way to work out a good decay mode for your stepper motor, if you can’t measure the current with an oscilloscope, is to listen to the sound of the motor. If the value is too low, you often hear a high pitched sound and if it is too high you can often hear a humming sound.

Generally, fast decay mode (small value) will be noisier but also allow higher motor speeds.

.. note

There is unfortunately no formula to calculate a perfect decay mode for a given stepper motor. If you have problems with loud noises or the maximum motor speed is too slow, you should try to tinker with the decay value



472
473
474
475
476
 
# File 'lib/tinkerforge/brick_stepper.rb', line 472

def set_decay(decay)
  check_validity

  send_request FUNCTION_SET_DECAY, [decay], 'S', 8, ''
end

#set_max_velocity(velocity) ⇒ Object

Sets the maximum velocity of the stepper motor. This function does not start the motor, it merely sets the maximum velocity the stepper motor is accelerated to. To get the motor running use either BrickStepper#set_target_position, BrickStepper#set_steps, BrickStepper#drive_forward or BrickStepper#drive_backward.



189
190
191
192
193
 
# File 'lib/tinkerforge/brick_stepper.rb', line 189

def set_max_velocity(velocity)
  check_validity

  send_request FUNCTION_SET_MAX_VELOCITY, [velocity], 'S', 8, ''
end

#set_minimum_voltage(voltage) ⇒ Object

Sets the minimum voltage, below which the CALLBACK_UNDER_VOLTAGE callback is triggered. The minimum possible value that works with the Stepper Brick is 8V. You can use this function to detect the discharge of a battery that is used to drive the stepper motor. If you have a fixed power supply, you likely do not need this functionality.



490
491
492
493
494
 
# File 'lib/tinkerforge/brick_stepper.rb', line 490

def set_minimum_voltage(voltage)
  check_validity

  send_request FUNCTION_SET_MINIMUM_VOLTAGE, [voltage], 'S', 8, ''
end

#set_motor_current(current) ⇒ Object

Sets the current with which the motor will be driven.

.. warning

Do not set this value above the specifications of your stepper motor. Otherwise it may damage your motor.



403
404
405
406
407
 
# File 'lib/tinkerforge/brick_stepper.rb', line 403

def set_motor_current(current)
  check_validity

  send_request FUNCTION_SET_MOTOR_CURRENT, [current], 'S', 8, ''
end

#set_speed_ramping(acceleration, deacceleration) ⇒ Object

Sets the acceleration and deacceleration of the stepper motor. An acceleration of 1000 means, that every second the velocity is increased by 1000 steps/s.

For example: If the current velocity is 0 and you want to accelerate to a velocity of 8000 steps/s in 10 seconds, you should set an acceleration of 800 steps/s².

An acceleration/deacceleration of 0 means instantaneous acceleration/deacceleration (not recommended)



219
220
221
222
223
 
# File 'lib/tinkerforge/brick_stepper.rb', line 219

def set_speed_ramping(acceleration, deacceleration)
  check_validity

  send_request FUNCTION_SET_SPEED_RAMPING, [acceleration, deacceleration], 'S S', 8, ''
end

#set_spitfp_baudrate(bricklet_port, baudrate) ⇒ Object

Sets the baudrate for a specific Bricklet port.

If you want to increase the throughput of Bricklets you can increase the baudrate. If you get a high error count because of high interference (see BrickStepper#get_spitfp_error_count) you can decrease the baudrate.

If the dynamic baudrate feature is enabled, the baudrate set by this function corresponds to the maximum baudrate (see BrickStepper#set_spitfp_baudrate_config).

Regulatory testing is done with the default baudrate. If CE compatibility or similar is necessary in your applications we recommend to not change the baudrate.

.. versionadded

2.3.3$nbsp;(Firmware)



638
639
640
641
642
 
# File 'lib/tinkerforge/brick_stepper.rb', line 638

def set_spitfp_baudrate(bricklet_port, baudrate)
  check_validity

  send_request FUNCTION_SET_SPITFP_BAUDRATE, [bricklet_port, baudrate], 'k L', 8, ''
end

#set_spitfp_baudrate_config(enable_dynamic_baudrate, minimum_dynamic_baudrate) ⇒ Object

The SPITF protocol can be used with a dynamic baudrate. If the dynamic baudrate is enabled, the Brick will try to adapt the baudrate for the communication between Bricks and Bricklets according to the amount of data that is transferred.

The baudrate will be increased exponentially if lots of data is sent/received and decreased linearly if little data is sent/received.

This lowers the baudrate in applications where little data is transferred (e.g. a weather station) and increases the robustness. If there is lots of data to transfer (e.g. Thermal Imaging Bricklet) it automatically increases the baudrate as needed.

In cases where some data has to transferred as fast as possible every few seconds (e.g. RS485 Bricklet with a high baudrate but small payload) you may want to turn the dynamic baudrate off to get the highest possible performance.

The maximum value of the baudrate can be set per port with the function BrickStepper#set_spitfp_baudrate. If the dynamic baudrate is disabled, the baudrate as set by BrickStepper#set_spitfp_baudrate will be used statically.

.. versionadded

2.3.6$nbsp;(Firmware)



594
595
596
597
598
 
# File 'lib/tinkerforge/brick_stepper.rb', line 594

def set_spitfp_baudrate_config(enable_dynamic_baudrate, minimum_dynamic_baudrate)
  check_validity

  send_request FUNCTION_SET_SPITFP_BAUDRATE_CONFIG, [enable_dynamic_baudrate, minimum_dynamic_baudrate], '? L', 8, ''
end

#set_step_mode(mode) ⇒ Object

Sets the step mode of the stepper motor. Possible values are:

  • Full Step = 1

  • Half Step = 2

  • Quarter Step = 4

  • Eighth Step = 8

A higher value will increase the resolution and decrease the torque of the stepper motor.



325
326
327
328
329
 
# File 'lib/tinkerforge/brick_stepper.rb', line 325

def set_step_mode(mode)
  check_validity

  send_request FUNCTION_SET_STEP_MODE, [mode], 'C', 8, ''
end

#set_steps(steps) ⇒ Object

Sets the number of steps the stepper motor should run. Positive values will drive the motor forward and negative values backward. The velocity, acceleration and deacceleration as set by BrickStepper#set_max_velocity and BrickStepper#set_speed_ramping will be used.



293
294
295
296
297
 
# File 'lib/tinkerforge/brick_stepper.rb', line 293

def set_steps(steps)
  check_validity

  send_request FUNCTION_SET_STEPS, [steps], 'l', 8, ''
end

#set_sync_rect(sync_rect) ⇒ Object

Turns synchronous rectification on or off (true or false).

With synchronous rectification on, the decay can be changed (see BrickStepper#set_decay). Without synchronous rectification fast decay is used.

For an explanation of synchronous rectification see ‘here <en.wikipedia.org/wiki/Active_rectification>`__.

.. warning

If you want to use high speeds (> 10000 steps/s) for a large stepper motor with a large inductivity we strongly suggest that you disable synchronous rectification. Otherwise the Brick may not be able to cope with the load and overheat.



517
518
519
520
521
 
# File 'lib/tinkerforge/brick_stepper.rb', line 517

def set_sync_rect(sync_rect)
  check_validity

  send_request FUNCTION_SET_SYNC_RECT, [sync_rect], '?', 8, ''
end

#set_target_position(position) ⇒ Object

Sets the target position of the stepper motor in steps. For example, if the current position of the motor is 500 and BrickStepper#set_target_position is called with 1000, the stepper motor will drive 500 steps forward. It will use the velocity, acceleration and deacceleration as set by BrickStepper#set_max_velocity and BrickStepper#set_speed_ramping.

A call of BrickStepper#set_target_position with the parameter x is equivalent to a call of BrickStepper#set_steps with the parameter (x - BrickStepper#get_current_position).



276
277
278
279
280
 
# File 'lib/tinkerforge/brick_stepper.rb', line 276

def set_target_position(position)
  check_validity

  send_request FUNCTION_SET_TARGET_POSITION, [position], 'l', 8, ''
end

#set_time_base(time_base) ⇒ Object

Sets the time base of the velocity and the acceleration of the stepper brick.

For example, if you want to make one step every 1.5 seconds, you can set the time base to 15 and the velocity to 10. Now the velocity is 10steps/15s = 1steps/1.5s.



535
536
537
538
539
 
# File 'lib/tinkerforge/brick_stepper.rb', line 535

def set_time_base(time_base)
  check_validity

  send_request FUNCTION_SET_TIME_BASE, [time_base], 'L', 8, ''
end

#stop ⇒ Object

Stops the stepper motor with the deacceleration as set by BrickStepper#set_speed_ramping.



358
359
360
361
362
 
# File 'lib/tinkerforge/brick_stepper.rb', line 358

def stop
  check_validity

  send_request FUNCTION_STOP, [], '', 8, ''
end

#write_bricklet_plugin(port, offset, chunk) ⇒ Object

Writes 32 bytes of firmware to the bricklet attached at the given port. The bytes are written to the position offset * 32.

This function is used by Brick Viewer during flashing. It should not be necessary to call it in a normal user program.



749
750
751
752
753
 
# File 'lib/tinkerforge/brick_stepper.rb', line 749

def write_bricklet_plugin(port, offset, chunk)
  check_validity

  send_request FUNCTION_WRITE_BRICKLET_PLUGIN, [port, offset, chunk], 'k C C32', 8, ''
end