# git clone repository
git clone [email protected]:BrainCoTech/stark-serialport-example.git
# install dependencies
build-essential, cmake, make, gcc, g++, etc...
# install sdk dependencies
./download-lib.sh
# Note:Users must be added to the "dialout" group to gain access over serial port device.
# If you haven't set, use the following command then restart your computer：
sudo usermod -aG dialout $USER
# NOTE: Modify serial_port_name to the actual serial port name
cd mac && make && make run # git clone repository
git clone [email protected]:BrainCoTech/stark-serialport-example.git
# install Xcode or Xcode Command Line Tools
# install sdk dependencies
./download-lib.sh
# NOTE: Modify serial_port_name to the actual serial port name
cd mac && make && make run typedef struct {
/* Device ID range: 10~254, the default is 1, 254 is the broadcast address, broadcast is only applicable to control instructions */
int serial_device_id; /* Device ID */
int baudrate; /* Baud rate, default is 115200 */
}
SerialPortCfg;
StarkDevice* stark_create_serial_device(const char* uuid, const int device_id);
// Serial port configuration reading
typedef void (*SerialPortCfgCB)(const char *device_id, SerialPortCfg *cfg);
void stark_get_serialport_cfg(StarkDevice* device, SerialPortCfgCB cb);
// The serial port configuration is modified, and the device will automatically restart after the modification
void stark_set_serial_baudrate(StarkDevice* device, int baudrate); // baudrate: 115200, 57600, 19200
void stark_set_serial_device_id(StarkDevice* device, int device_id); // device_id
// Set the serial port read and write callback
int stark_did_receive_data(StarkDevice* device, const uint8_t* data, int size);
typedef int (*WriteDataCB)(const char *device_id, const uint8_t *data, int size);
void stark_set_write_data_callback(WriteDataCB cb);
typedef int (*ModbusWriteCB)(const char *device_id, const uint16_t *data, int register_address, int count);
typedef uint16_t * (*ModbusReadValuesCB)(const char *device_id, int register_address, int count);
typedef uint16_t (*ModbusReadValueCB)(const char *device_id, int register_address);
void modbus_set_write_registers_callback(StarkDevice *device, ModbusWriteCB cb);
void modbus_set_read_holding_register_callback(StarkDevice *device, ModbusReadValueCB cb);
void modbus_set_read_holding_registers_callback(StarkDevice *device, ModbusReadValuesCB cb);
void modbus_set_read_input_register_callback(StarkDevice *device, ModbusReadValueCB cb);
void modbus_set_read_input_registers_callback(StarkDevice *device, ModbusReadValuesCB cb); typedef enum {
MEDIUM_RIGHT = 1,
MEDIUM_LEFT = 2,
SMALL_RIGHT = 3,
SMALL_LEFT = 4
}
StarkHandType;
typedef struct {
int hand_type; /* Device Type */
char sn[20]; /* Serial Number */
char fw_version[20]; /* Firmware version */
}
MotorboardInfo;
// Get device information
typedef void (*MotorboardInfoCB)(const char *device_id, MotorboardInfo *info);
void stark_get_motorboard_info(StarkDevice* device, MotorboardInfoCB cb);
// Get the hand type
void stark_get_hand_type(StarkDevice* device, StarkIntValueCB cb);
// Get voltage information
void stark_get_voltage(StarkDevice* device, StarkFloatValueCB cb); // Set the position, range: 0~100, 0 is maximum extension, 100 is maximum grip
void stark_set_finger_position(StarkDevice *device, int finger_position);
void stark_set_finger_positions(StarkDevice* device, const int finger_positions[6]); // Strength
typedef enum {
STARK_FORCE_LEVEL_SMALL = 1,
STARK_FORCE_LEVEL_NORMAL = 2,
STARK_FORCE_LEVEL_FULL = 3,
}
StarkForceLevel;
// Read the force setting
void stark_get_force_level(StarkDevice* device, StarkIntValueCB cb);
// Set the force
void stark_set_force_level(StarkDevice* device, int force_level); // Finger number
typedef enum {
FINGERID_THUMB = 1,
FINGERID_THUMB_AUX = 2,
FINGERID_INDEX = 3,
FINGERID_MIDDLE = 4,
FINGERID_RING = 5,
FINGERID_PINKY = 6
}
StarkFingerId;
// Single finger information
typedef struct {
uint8_t finger_positions[6]; // 0 ~ 100 for each finger. 0 for fully open, 100 for fully close
int8_t finger_speeds[6]; // -100 ~ +100 for each finger. 0 for stop, positive number for close finger, negative number for open finger.
int8_t finger_currents[6]; // -100 ~ +100 for each finger. Fraction of max motor current, absolute number.
int8_t finger_pwms[6]; // -100 ~ +100 for each motor.
}
StarkFingerStatus;
// All finger information
typedef struct {
int n_finger_status;
StarkFingerStatus** finger_status;
}
FingerStatusData;
// Get finger information:location,speed,current,PWM
typedef void (*FingerStatusCB)(const char *device_id, FingerStatusData *data);
void stark_get_finger_status(StarkDevice* device, FingerStatusCB cb);
// // Get location
// void stark_get_finger_positions(StarkDevice *device, StarkUint16ValuesCB cb);
// // Get speed
// void stark_get_finger_speeds(StarkDevice *device, StarkUint16ValuesCB cb);
// // Get current
// void stark_get_finger_currents(StarkDevice *device, StarkUint16ValuesCB cb); typedef struct {
uint16_t normal_force1; // Normal force 1, unit: mN
uint16_t normal_force2; // Normal force 2, unit: mN
uint16_t normal_force3; // Normal force 3, unit: mN
uint16_t tangential_force1; // Tangential force 1, unit: mN
uint16_t tangential_force2; // Tangential force 2, unit: mN
uint16_t tangential_force3; // Tangential force 3, unit: mN
uint16_t tangential_direction1; // Tangential force direction 1, unit: degrees
uint16_t tangential_direction2; // Tangential force direction 2, unit: degrees度
uint16_t tangential_direction3; // Tangential force direction 3, unit: degrees
uint32_t self_close1; // Self-approaching induction 1
uint32_t self_close2; // Self-approaching induction 2
uint32_t mutual_close; // Mutual approaching induction
uint16_t status; // 1 indicates abnormal, 0 indicates normal
} TouchStatus;
typedef struct {
int n_touch_status; // 5 fingers
TouchStatus **touch_status;
} TouchStatusData;
typedef void (*TouchStatusCB)(const char *device_id, TouchStatusData *data);
void stark_get_touch_sensor_status(StarkDevice *device, TouchStatusCB cb);
void stark_get_touch_sensor_firmware(StarkDevice *device, StarkFWVersionsCB cb);
// Tactile sensor reset and calibration
void stark_touch_sensor_reset(StarkDevice *device, uint32_t finger_bits);
void stark_touch_sensor_calibrate(StarkDevice *device, uint32_t finger_bits); typedef struct {
int timestamp;
int button_id;
int press_status; // StarkPressState
} ButtonPressEvent;
//
Backhand button status
typedef enum {
PRESSING = 1,
NOT_PRESSING = 2,
} StarkPressState;
// Button event
typedef struct {
int timestamp;
int button_id;
int press_status; // StarkPressState
} ButtonPressEvent;
Get button event
typedef void (*ButtonEventCB)(const char *device_id, ButtonPressEvent *event);
void stark_get_button_event(StarkDevice *device, ButtonEventCB cb); // LED color
typedef enum {
LED_COLOR_UNCHANGED = 0, // not equal to OFF, since majorly use LedMode to turn-off LED.
LED_COLOR_R = 1,
LED_COLOR_G = 2,
LED_COLOR_RG = 3,
LED_COLOR_B = 4,
LED_COLOR_RB = 5,
LED_COLOR_GB = 6,
LED_COLOR_RGB = 7
} StarkLedColor;
// LED mode
typedef enum {
LED_MODE_SHUTDOWN = 1, // turn-off LED
LED_MODE_KEEP = 2,
LED_MODE_BLINK = 3, // 1Hz freq on-off cycle, 50% duty cycle
LED_MODE_ONE_SHOT = 4, // on-100ms, then off, no repeat, if repeatedly receive this, time counter will be reset at each time received (e.g., repeatedly receive interval <= 100ms equal always on)
LED_MODE_BLINK0_5HZ = 5, // 0.5Hz freq on-off cycle, 50% duty cycle
LED_MODE_BLINK2HZ = 6 // 2Hz freq on-off cycle, 50% duty cycle
} StarkLedMode;
// LED info
typedef struct {
int led_color; // LED color StarkLedColor
int led_mode; // LED mode StarkLedMode
} LedInfo;
typedef void (*LedInfoCB)(const char *device_id, LedInfo *info);
void stark_get_led_info(StarkDevice *device, LedInfoCB cb);
void stark_set_led_info(StarkDevice *device, int led_mode, int led_color); // StarkLedMode, StarkLedColor // OTA upgrade Status
typedef enum {
STARK_DFU_STATE_IDLE = 0,
STARK_DFU_STATE_ENABLING = 1, // Enabling OTA mode
STARK_DFU_STATE_STARTED = 2, // Entered OTA mode
STARK_DFU_STATE_TRANSFER = 3, // OTA upgrading
STARK_DFU_STATE_COMPLETED = 4, // OTA upgrade done
STARK_DFU_STATE_ABORTED = 5, // OTA upgrade interruption
} StarkDfuState;
typedef void (*DfuReadCB)(const char *device_id);
typedef void (*DfuStateCB)(const char *device_id, int state);
typedef void (*DfuProgressCB)(const char *device_id, float progress); // progress: 0.0 ~ 1.0
const char* stark_dfu_state_to_string(int state);
void stark_set_dfu_read_callback(StarkDevice *device, DfuReadCB cb);
void stark_set_dfu_state_callback(StarkDevice *device, DfuStateCB cb);
void stark_set_dfu_progress_callback(StarkDevice *device, DfuProgressCB cb);
void stark_set_dfu_cfg(StarkDevice *device,
uint8_t dfu_enabling_delay /* = 8 */, /* Delay time for enabling DFU (1~30 seconds) in */
uint8_t dfu_enabling_interval /* = 10 */, /* Retry interval for enabling DFU (1~30 seconds) */
uint8_t dfu_applying_delay /* = 10 */); /* Waiting time for applying new firmware (1~30 seconds) */
void stark_start_dfu(StarkDevice *device, const char *dfu_file_path);
void stark_abort_dfu(StarkDevice *device);