dynamixel
Version:
Node.js library for controlling DYNAMIXEL servo motors via U2D2 interface with Protocol 2.0 support
291 lines (290 loc) • 10.6 kB
TypeScript
/**
* Individual DYNAMIXEL Device
* Represents a single DYNAMIXEL motor with its specific capabilities
*/
export class DynamixelDevice extends EventEmitter<[never]> {
constructor(id: any, connection: any, deviceInfo?: {});
id: any;
connection: any;
modelNumber: any;
firmwareVersion: any;
modelName: any;
lastError: any;
indirectMappings: Map<any, any>;
/**
* Ping this device to check if it's responsive
* @param {number} timeout - Timeout in milliseconds
* @returns {Promise<Object>} - Device information
*/
ping(timeout?: number): Promise<Object>;
/**
* Read data from the device's control table
* @param {number} address - Control table address
* @param {number} length - Number of bytes to read
* @param {number} timeout - Timeout in milliseconds
* @returns {Promise<Buffer>} - Read data
*/
read(address: number, length: number, timeout?: number): Promise<Buffer>;
/**
* Write data to the device's control table
* @param {number} address - Control table address
* @param {Buffer|Array} data - Data to write
* @param {number} timeout - Timeout in milliseconds
* @returns {Promise<boolean>} - Success status
*/
write(address: number, data: Buffer | any[], timeout?: number): Promise<boolean>;
/**
* Get realtime tick
* @returns {Promise<number>} - timestamp in ms (rolls over at 32767)
*/
getRealtimeTick(): Promise<number>;
/**
* Read a 1-byte value from control table
* @param {number} address - Control table address
* @returns {Promise<number>} - 8-bit value
*/
readByte(address: number): Promise<number>;
/**
* Read a 2-byte value from control table (little-endian)
* @param {number} address - Control table address
* @returns {Promise<number>} - 16-bit value
*/
readWord(address: number): Promise<number>;
/**
* Read a 4-byte value from control table (little-endian)
* @param {number} address - Control table address
* @returns {Promise<number>} - 32-bit value
*/
readDWord(address: number): Promise<number>;
/**
* Write a 1-byte value to control table
* @param {number} address - Control table address
* @param {number} value - 8-bit value
* @returns {Promise<boolean>} - Success status
*/
writeByte(address: number, value: number): Promise<boolean>;
/**
* Write a 2-byte value to control table (little-endian)
* @param {number} address - Control table address
* @param {number} value - 16-bit value
* @returns {Promise<boolean>} - Success status
*/
writeWord(address: number, value: number): Promise<boolean>;
/**
* Write a 4-byte value to control table (little-endian)
* @param {number} address - Control table address
* @param {number} value - 32-bit value
* @returns {Promise<boolean>} - Success status
*/
writeDWord(address: number, value: number): Promise<boolean>;
/**
* Enable/disable torque
* @param {boolean} enable - True to enable, false to disable
* @returns {Promise<boolean>} - Success status
*/
setTorqueEnable(enable: boolean): Promise<boolean>;
/**
* Get torque enable status
* @returns {Promise<boolean>} - Torque enable status
*/
getTorqueEnable(): Promise<boolean>;
/**
* Set goal position
* @param {number} position - Goal position (0-4095 for most models)
* @returns {Promise<boolean>} - Success status
*/
setGoalPosition(position: number): Promise<boolean>;
/**
* Get goal position
* @returns {Promise<number>} - Goal position
*/
getGoalPosition(): Promise<number>;
/**
* Get present position
* @returns {Promise<number>} - Present position
*/
getPresentPosition(): Promise<number>;
/**
* Set goal velocity
* @param {number} velocity - Goal velocity
* @returns {Promise<boolean>} - Success status
*/
setGoalVelocity(velocity: number): Promise<boolean>;
/**
* Get goal velocity
* @returns {Promise<number>} - Goal velocity
*/
getGoalVelocity(): Promise<number>;
/**
* Get present velocity
* @returns {Promise<number>} - Present velocity
*/
getPresentVelocity(): Promise<number>;
/**
* Set goal PWM
* @param {number} pwm - Goal PWM value
* @returns {Promise<boolean>} - Success status
*/
setGoalPWM(pwm: number): Promise<boolean>;
/**
* Get present PWM
* @returns {Promise<number>} - Present PWM
*/
getPresentPWM(): Promise<number>;
/**
* Get present temperature
* @returns {Promise<number>} - Temperature in Celsius
*/
getPresentTemperature(): Promise<number>;
/**
* Set goal current
* @param {number} current - Goal current (0-max mA)
* @returns {Promise<boolean>} - Success status
*/
setGoalCurrent(current: number): Promise<boolean>;
/**
* Get goal current
* @returns {Promise<number>} - Current in mA
*/
getGoalCurrent(): Promise<number>;
/**
* Get present voltage
* @returns {Promise<number>} - Voltage in 0.1V units
*/
getPresentVoltage(): Promise<number>;
/**
* Set LED state
* @param {boolean} on - True to turn on, false to turn off
* @returns {Promise<boolean>} - Success status
*/
setLED(on: boolean): Promise<boolean>;
/**
* Get LED state
* @returns {Promise<boolean>} - LED state
*/
getLED(): Promise<boolean>;
/**
* Check if device is moving
* @returns {Promise<boolean>} - Moving status
*/
isMoving(): Promise<boolean>;
/**
* Reboot the device
* @param {number} timeout - Timeout in milliseconds
* @returns {Promise<boolean>} - Success status
*/
reboot(timeout?: number): Promise<boolean>;
/**
* Get device information summary
* @returns {Object} - Device information
*/
getDeviceInfo(): Object;
/**
* Get model name from model number
* @param {number} modelNumber - Model number
* @returns {string} - Model name
*/
getModelName(modelNumber: number): string;
/**
* Convert position to degrees (assuming 0-4095 range)
* @param {number} position - Position value
* @returns {number} - Degrees (0-360)
*/
positionToDegrees(position: number): number;
/**
* Convert degrees to position (assuming 0-4095 range)
* @param {number} degrees - Degrees (0-360)
* @returns {number} - Position value
*/
degreesToPosition(degrees: number): number;
/**
* Convert velocity to RPM (model-specific)
* @param {number} velocity - Velocity value
* @returns {number} - RPM
*/
velocityToRPM(velocity: number): number;
/**
* Convert RPM to velocity (model-specific)
* @param {number} rpm - RPM
* @returns {number} - Velocity value
*/
rpmToVelocity(rpm: number): number;
/**
* Convert voltage reading to actual voltage
* @param {number} voltageReading - Raw voltage reading
* @returns {number} - Voltage in volts
*/
voltageToVolts(voltageReading: number): number;
/**
* Generate standardized error messages for indirect addressing operations
* @param {string} type - Error type ('indexOutOfRange', 'indexNotMapped', 'invalidValue', 'targetOutOfRange')
* @param {Object} params - Parameters for the error message
* @returns {string} - Formatted error message
*/
getIndirectAddressErrorMessage(type: string, params: Object): string;
/**
* Setup indirect address mapping
* Maps a control table address to an indirect address slot
* @param {number} index - Indirect address index (0-19)
* @param {number} targetAddress - Control table address to map
* @returns {Promise<boolean>} - Success status
*/
setupIndirectAddress(index: number, targetAddress: number): Promise<boolean>;
/**
* Write data through indirect addressing
* @param {number} index - Indirect address index
* @param {number} value - Value to write (1 byte)
* @returns {Promise<boolean>} - Success status
*/
writeIndirectData(index: number, value: number): Promise<boolean>;
/**
* Read data through indirect addressing
* @param {number} index - Indirect address index
* @returns {Promise<number>} - Read value (1 byte)
*/
readIndirectData(index: number): Promise<number>;
/**
* Bulk read multiple indirect data addresses
* @param {number[]} indices - Array of indirect address indices
* @returns {Promise<Object>} - Map of index to value
*/
bulkReadIndirect(indices: number[]): Promise<Object>;
/**
* Bulk write multiple indirect data addresses
* @param {Object} mappings - Object with index as key and value as data
* @returns {Promise<boolean>} - Success status
*/
bulkWriteIndirect(mappings: Object): Promise<boolean>;
/**
* Clear indirect mapping for a specific index
* @param {number} index - Indirect address index to clear
* @returns {Promise<boolean>} - Success status
*/
clearIndirectMapping(index: number): Promise<boolean>;
/**
* Clear all indirect mappings
* @returns {Promise<boolean>} - Success status
*/
clearAllIndirectMappings(): Promise<boolean>;
/**
* Get current indirect address mappings
* @returns {Map} - Map of index to target address
*/
getIndirectMappings(): Map<any, any>;
/**
* Setup common indirect mappings for monitoring
* @returns {Promise<boolean>} - Success status
*/
setupCommonIndirectMappings(): Promise<boolean>;
/**
* Read all common monitoring values through indirect addressing
* @returns {Promise<Object>} - Object containing position, velocity, pwm, temperature, moving
* @warning The returned values are incomplete for multi-byte fields:
* - position: Only 1 byte of 4-byte value (use consecutive indirect mappings for full values)
* - velocity: Only 1 byte of 4-byte value (use consecutive indirect mappings for full values)
* - pwm: Only 1 byte of 2-byte value (use consecutive indirect mappings for full values)
* For complete values, map consecutive indirect addresses to cover all bytes
*/
readCommonStatus(): Promise<Object>;
}
import { EventEmitter } from 'events';