/* ***********************************************************
* This file was automatically generated on 2013-12-19. *
* *
* Bindings Version 2.0.13 *
* *
* If you have a bugfix for this file and want to commit it, *
* please fix the bug in the generator. You can find a link *
* to the generator git on tinkerforge.com *
*************************************************************/
using System;
namespace Tinkerforge
{
///
/// Device for controlling DC motors
///
public class BrickDC : Device
{
///
/// Used to identify this device type in
///
///
public static Enums.DeviceIdentifier DEVICE_IDENTIFIER = Enums.DeviceIdentifier.BrickDC;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_VELOCITY = 1;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_VELOCITY = 2;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_CURRENT_VELOCITY = 3;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_ACCELERATION = 4;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_ACCELERATION = 5;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_PWM_FREQUENCY = 6;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_PWM_FREQUENCY = 7;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_FULL_BRAKE = 8;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_STACK_INPUT_VOLTAGE = 9;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE = 10;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_CURRENT_CONSUMPTION = 11;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_ENABLE = 12;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_DISABLE = 13;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_IS_ENABLED = 14;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_MINIMUM_VOLTAGE = 15;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_MINIMUM_VOLTAGE = 16;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_DRIVE_MODE = 17;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_DRIVE_MODE = 18;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_SET_CURRENT_VELOCITY_PERIOD = 19;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_CURRENT_VELOCITY_PERIOD = 20;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte CALLBACK_UNDER_VOLTAGE = 21;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte CALLBACK_EMERGENCY_SHUTDOWN = 22;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte CALLBACK_VELOCITY_REACHED = 23;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte CALLBACK_CURRENT_VELOCITY = 24;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_PROTOCOL1_BRICKLET_NAME = 241;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_CHIP_TEMPERATURE = 242;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_RESET = 243;
///
/// Function ID to be used with
/// ,
/// and
/// .
///
public const byte FUNCTION_GET_IDENTITY = 255;
///
///
public const byte DRIVE_MODE_DRIVE_BRAKE = 0;
///
///
public const byte DRIVE_MODE_DRIVE_COAST = 1;
///
/// This callback is triggered when the input voltage drops below the value set by
/// . The parameter is the current voltage given
/// in mV.
///
public event UnderVoltageEventHandler UnderVoltage;
///
///
public delegate void UnderVoltageEventHandler(BrickDC sender, int voltage);
///
/// This callback is triggered if either the current consumption
/// is too high (above 5A) or the temperature of the driver chip is too high
/// (above 175°C). These two possibilities are essentially the same, since the
/// temperature will reach this threshold immediately if the motor consumes too
/// much current. In case of a voltage below 3.3V (external or stack) this
/// callback is triggered as well.
///
/// If this callback is triggered, the driver chip gets disabled at the same time.
/// That means, has to be called to drive the motor again.
///
///
/// This callback only works in Drive/Brake mode (see ). In
/// Drive/Coast mode it is unfortunately impossible to reliably read the
/// overcurrent/overtemperature signal from the driver chip.
///
///
public event EmergencyShutdownEventHandler EmergencyShutdown;
///
///
public delegate void EmergencyShutdownEventHandler(BrickDC sender);
///
/// This callback is triggered whenever a set velocity is reached. For example:
/// If a velocity of 0 is present, acceleration is set to 5000 and velocity
/// to 10000, will be triggered after about 2 seconds, when
/// the set velocity is actually reached.
///
///
/// Since we can't get any feedback from the DC motor, this only works if the
/// acceleration (see ) 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.
///
///
public event VelocityReachedEventHandler VelocityReached;
///
///
public delegate void VelocityReachedEventHandler(BrickDC sender, short velocity);
///
/// This callback is triggered with the period that is set by
/// . The parameter is the *current* velocity
/// used by the motor.
///
/// is only triggered after the set period if there is
/// a change in the velocity.
///
public event CurrentVelocityEventHandler CurrentVelocity;
///
///
public delegate void CurrentVelocityEventHandler(BrickDC sender, short velocity);
///
/// Creates an object with the unique device ID uid and adds it to
/// the IPConnection ipcon.
///
public BrickDC(string uid, IPConnection ipcon) : base(uid, ipcon)
{
this.apiVersion[0] = 2;
this.apiVersion[1] = 0;
this.apiVersion[2] = 0;
callbackWrappers[CALLBACK_UNDER_VOLTAGE] = new CallbackWrapper(OnUnderVoltage);
callbackWrappers[CALLBACK_EMERGENCY_SHUTDOWN] = new CallbackWrapper(OnEmergencyShutdown);
callbackWrappers[CALLBACK_VELOCITY_REACHED] = new CallbackWrapper(OnVelocityReached);
callbackWrappers[CALLBACK_CURRENT_VELOCITY] = new CallbackWrapper(OnCurrentVelocity);
responseExpected[FUNCTION_SET_VELOCITY] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_VELOCITY] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_GET_CURRENT_VELOCITY] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_SET_ACCELERATION] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_ACCELERATION] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_SET_PWM_FREQUENCY] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_PWM_FREQUENCY] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_FULL_BRAKE] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_STACK_INPUT_VOLTAGE] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_GET_CURRENT_CONSUMPTION] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_ENABLE] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_DISABLE] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_IS_ENABLED] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_SET_MINIMUM_VOLTAGE] = ResponseExpectedFlag.TRUE;
responseExpected[FUNCTION_GET_MINIMUM_VOLTAGE] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_SET_DRIVE_MODE] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_DRIVE_MODE] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_SET_CURRENT_VELOCITY_PERIOD] = ResponseExpectedFlag.TRUE;
responseExpected[FUNCTION_GET_CURRENT_VELOCITY_PERIOD] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_GET_PROTOCOL1_BRICKLET_NAME] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_GET_CHIP_TEMPERATURE] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[FUNCTION_RESET] = ResponseExpectedFlag.FALSE;
responseExpected[FUNCTION_GET_IDENTITY] = ResponseExpectedFlag.ALWAYS_TRUE;
responseExpected[CALLBACK_UNDER_VOLTAGE] = ResponseExpectedFlag.ALWAYS_FALSE;
responseExpected[CALLBACK_EMERGENCY_SHUTDOWN] = ResponseExpectedFlag.ALWAYS_FALSE;
responseExpected[CALLBACK_VELOCITY_REACHED] = ResponseExpectedFlag.ALWAYS_FALSE;
responseExpected[CALLBACK_CURRENT_VELOCITY] = ResponseExpectedFlag.ALWAYS_FALSE;
}
///
/// Sets the velocity of the motor. Whereas -32767 is full speed backward,
/// 0 is stop and 32767 is full speed forward. Depending on the
/// acceleration (see ), the motor is not immediately
/// brought to the velocity but smoothly accelerated.
///
/// The velocity describes the duty cycle of the PWM with which the motor is
/// controlled, e.g. a velocity of 3277 sets a PWM with a 10% duty cycle.
/// You can not only control the duty cycle of the PWM but also the frequency,
/// see .
///
/// The default velocity is 0.
///
public void SetVelocity(short velocity)
{
byte[] request = CreateRequestPacket(10, FUNCTION_SET_VELOCITY);
LEConverter.To((short)velocity, 8, request);
SendRequest(request);
}
///
/// Returns the velocity as set by .
///
public short GetVelocity()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_VELOCITY);
byte[] response = SendRequest(request);
return LEConverter.ShortFrom(8, response);
}
///
/// Returns the *current* velocity of the motor. This value is different
/// from whenever the motor is currently accelerating
/// to a goal set by .
///
public short GetCurrentVelocity()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_CURRENT_VELOCITY);
byte[] response = SendRequest(request);
return LEConverter.ShortFrom(8, response);
}
///
/// Sets the acceleration of the motor. It is given in *velocity/s*. An
/// acceleration of 10000 means, that every second the velocity is increased
/// by 10000 (or about 30% duty cycle).
///
/// For example: If the current velocity is 0 and you want to accelerate to a
/// velocity of 16000 (about 50% duty cycle) in 10 seconds, you should set
/// an acceleration of 1600.
///
/// If acceleration is set to 0, there is no speed ramping, i.e. a new velocity
/// is immediately given to the motor.
///
/// The default acceleration is 10000.
///
public void SetAcceleration(int acceleration)
{
byte[] request = CreateRequestPacket(10, FUNCTION_SET_ACCELERATION);
LEConverter.To((short)acceleration, 8, request);
SendRequest(request);
}
///
/// Returns the acceleration as set by .
///
public int GetAcceleration()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_ACCELERATION);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Sets the frequency (in Hz) of the PWM with which the motor is driven.
/// The possible range of the frequency is 1-20000Hz. Often a high frequency
/// is less noisy and the motor runs smoother. However, with a low frequency
/// there are less switches and therefore fewer switching losses. Also with
/// most motors lower frequencies enable higher torque.
///
/// If you have no idea what all this means, just ignore this function and use
/// the default frequency, it will very likely work fine.
///
/// The default frequency is 15 kHz.
///
public void SetPWMFrequency(int frequency)
{
byte[] request = CreateRequestPacket(10, FUNCTION_SET_PWM_FREQUENCY);
LEConverter.To((short)frequency, 8, request);
SendRequest(request);
}
///
/// Returns the PWM frequency (in Hz) as set by .
///
public int GetPWMFrequency()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_PWM_FREQUENCY);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Executes an active full brake.
///
///
/// 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 with 0 if you just want to stop the motor.
///
public void FullBrake()
{
byte[] request = CreateRequestPacket(8, FUNCTION_FULL_BRAKE);
SendRequest(request);
}
///
/// Returns the stack input voltage in mV. 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.
///
public int GetStackInputVoltage()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_STACK_INPUT_VOLTAGE);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Returns the external input voltage in mV. The external input voltage is
/// given via the black power input connector on the DC 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.
///
///
/// 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.
///
///
public int GetExternalInputVoltage()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_EXTERNAL_INPUT_VOLTAGE);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Returns the current consumption of the motor in mA.
///
public int GetCurrentConsumption()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_CURRENT_CONSUMPTION);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Enables the driver chip. The driver parameters can be configured (velocity,
/// acceleration, etc) before it is enabled.
///
public void Enable()
{
byte[] request = CreateRequestPacket(8, FUNCTION_ENABLE);
SendRequest(request);
}
///
/// Disables the driver chip. The configurations are kept (velocity,
/// acceleration, etc) but the motor is not driven until it is enabled again.
///
public void Disable()
{
byte[] request = CreateRequestPacket(8, FUNCTION_DISABLE);
SendRequest(request);
}
///
/// Returns *true* if the driver chip is enabled, *false* otherwise.
///
public bool IsEnabled()
{
byte[] request = CreateRequestPacket(8, FUNCTION_IS_ENABLED);
byte[] response = SendRequest(request);
return LEConverter.BoolFrom(8, response);
}
///
/// Sets the minimum voltage in mV, below which the callback
/// is triggered. The minimum possible value that works with the DC Brick is 5V.
/// You can use this function to detect the discharge of a battery that is used
/// to drive the motor. If you have a fixed power supply, you likely do not need
/// this functionality.
///
/// The default value is 5V.
///
public void SetMinimumVoltage(int voltage)
{
byte[] request = CreateRequestPacket(10, FUNCTION_SET_MINIMUM_VOLTAGE);
LEConverter.To((short)voltage, 8, request);
SendRequest(request);
}
///
/// Returns the minimum voltage as set by
///
public int GetMinimumVoltage()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_MINIMUM_VOLTAGE);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// Sets the drive mode. Possible modes are:
///
/// * 0 = Drive/Brake
/// * 1 = Drive/Coast
///
/// These modes are different kinds of motor controls.
///
/// In Drive/Brake mode, the motor is always either driving or braking. There
/// is no freewheeling. Advantages are: A more linear correlation between
/// PWM and velocity, more exact accelerations and the possibility to drive
/// with slower velocities.
///
/// In Drive/Coast mode, the motor is always either driving or freewheeling.
/// Advantages are: Less current consumption and less demands on the motor and
/// driver chip.
///
/// The default value is 0 = Drive/Brake.
///
public void SetDriveMode(byte mode)
{
byte[] request = CreateRequestPacket(9, FUNCTION_SET_DRIVE_MODE);
LEConverter.To((byte)mode, 8, request);
SendRequest(request);
}
///
/// Returns the drive mode, as set by .
///
public byte GetDriveMode()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_DRIVE_MODE);
byte[] response = SendRequest(request);
return LEConverter.ByteFrom(8, response);
}
///
/// Sets a period in ms with which the callback is triggered.
/// A period of 0 turns the callback off.
///
/// The default value is 0.
///
public void SetCurrentVelocityPeriod(int period)
{
byte[] request = CreateRequestPacket(10, FUNCTION_SET_CURRENT_VELOCITY_PERIOD);
LEConverter.To((short)period, 8, request);
SendRequest(request);
}
///
/// Returns the period as set by .
///
public int GetCurrentVelocityPeriod()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_CURRENT_VELOCITY_PERIOD);
byte[] response = SendRequest(request);
return LEConverter.UShortFrom(8, response);
}
///
/// 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.
///
/// .. versionadded:: 2.0.0~(Firmware)
///
public void GetProtocol1BrickletName(char port, out byte protocolVersion, out byte[] firmwareVersion, out string name)
{
byte[] request = CreateRequestPacket(9, FUNCTION_GET_PROTOCOL1_BRICKLET_NAME);
LEConverter.To((char)port, 8, request);
byte[] response = SendRequest(request);
protocolVersion = LEConverter.ByteFrom(8, response);
firmwareVersion = LEConverter.ByteArrayFrom(9, response, 3);
name = LEConverter.StringFrom(12, response, 40);
}
///
/// Returns the temperature in °C/10 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.
///
/// .. versionadded:: 1.1.3~(Firmware)
///
public short GetChipTemperature()
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_CHIP_TEMPERATURE);
byte[] response = SendRequest(request);
return LEConverter.ShortFrom(8, response);
}
///
/// 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!
///
/// .. versionadded:: 1.1.3~(Firmware)
///
public void Reset()
{
byte[] request = CreateRequestPacket(8, FUNCTION_RESET);
SendRequest(request);
}
///
/// 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 can be '0'-'8' (stack position).
///
/// The device identifiers can be found :ref:`here <device_identifier>`.
///
/// .. versionadded:: 2.0.0~(Firmware)
///
public override void GetIdentity(out string uid, out string connectedUid, out char position, out byte[] hardwareVersion, out byte[] firmwareVersion, out int deviceIdentifier)
{
byte[] request = CreateRequestPacket(8, FUNCTION_GET_IDENTITY);
byte[] response = SendRequest(request);
uid = LEConverter.StringFrom(8, response, 8);
connectedUid = LEConverter.StringFrom(16, response, 8);
position = LEConverter.CharFrom(24, response);
hardwareVersion = LEConverter.ByteArrayFrom(25, response, 3);
firmwareVersion = LEConverter.ByteArrayFrom(28, response, 3);
deviceIdentifier = LEConverter.UShortFrom(31, response);
}
///
///
protected void OnUnderVoltage(byte[] response)
{
int voltage = LEConverter.UShortFrom(8, response);
var handler = UnderVoltage;
if(handler != null)
{
handler(this, voltage);
}
}
///
///
protected void OnEmergencyShutdown(byte[] response)
{
var handler = EmergencyShutdown;
if(handler != null)
{
handler(this);
}
}
///
///
protected void OnVelocityReached(byte[] response)
{
short velocity = LEConverter.ShortFrom(8, response);
var handler = VelocityReached;
if(handler != null)
{
handler(this, velocity);
}
}
///
///
protected void OnCurrentVelocity(byte[] response)
{
short velocity = LEConverter.ShortFrom(8, response);
var handler = CurrentVelocity;
if(handler != null)
{
handler(this, velocity);
}
}
}
}