int io4_get_monoflop(IO4 *io4, uint8_t pin, uint8_t *ret_value, uint32_t *ret_time, uint32_t *ret_time_remaining) { DevicePrivate *device_p = io4->p; GetMonoflop_ request; GetMonoflopResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IO4_FUNCTION_GET_MONOFLOP, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.pin = pin; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_value = response.value; *ret_time = leconvert_uint32_from(response.time); *ret_time_remaining = leconvert_uint32_from(response.time_remaining); return ret; }
int servo_get_current_velocity(Servo *servo, uint8_t servo_num, uint16_t *ret_velocity) { DevicePrivate *device_p = servo->p; GetCurrentVelocity_ request; GetCurrentVelocityResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_CURRENT_VELOCITY, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_velocity = leconvert_uint16_from(response.velocity); return ret; }
int servo_get_pulse_width(Servo *servo, uint8_t servo_num, uint16_t *ret_min, uint16_t *ret_max) { DevicePrivate *device_p = servo->p; GetPulseWidth_ request; GetPulseWidthResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_PULSE_WIDTH, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_min = leconvert_uint16_from(response.min); *ret_max = leconvert_uint16_from(response.max); return ret; }
int servo_get_protocol1_bricklet_name(Servo *servo, char port, uint8_t *ret_protocol_version, uint8_t ret_firmware_version[3], char ret_name[40]) { DevicePrivate *device_p = servo->p; GetProtocol1BrickletName_ request; GetProtocol1BrickletNameResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.port = port; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_protocol_version = response.protocol_version; memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); strncpy(ret_name, response.name, 40); return ret; }
int servo_is_enabled(Servo *servo, uint8_t servo_num, bool *ret_enabled) { DevicePrivate *device_p = servo->p; IsEnabled_ request; IsEnabledResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_IS_ENABLED, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_enabled = response.enabled; return ret; }
int industrial_digital_in_4_get_identity(IndustrialDigitalIn4 *industrial_digital_in_4, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) { DevicePrivate *device_p = industrial_digital_in_4->p; GetIdentity_ request; GetIdentityResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_DIGITAL_IN_4_FUNCTION_GET_IDENTITY, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } strncpy(ret_uid, response.uid, 8); strncpy(ret_connected_uid, response.connected_uid, 8); *ret_position = response.position; memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t)); memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); *ret_device_identifier = leconvert_uint16_from(response.device_identifier); return ret; }
int humidity_v2_get_spitfp_error_count(HumidityV2 *humidity_v2, uint32_t *ret_error_count_ack_checksum, uint32_t *ret_error_count_message_checksum, uint32_t *ret_error_count_frame, uint32_t *ret_error_count_overflow) { DevicePrivate *device_p = humidity_v2->p; GetSPITFPErrorCount_Request request; GetSPITFPErrorCount_Response response; int ret; ret = packet_header_create(&request.header, sizeof(request), HUMIDITY_V2_FUNCTION_GET_SPITFP_ERROR_COUNT, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_error_count_ack_checksum = leconvert_uint32_from(response.error_count_ack_checksum); *ret_error_count_message_checksum = leconvert_uint32_from(response.error_count_message_checksum); *ret_error_count_frame = leconvert_uint32_from(response.error_count_frame); *ret_error_count_overflow = leconvert_uint32_from(response.error_count_overflow); return ret; }
int imu_get_angular_velocity(IMU *imu, int16_t *ret_x, int16_t *ret_y, int16_t *ret_z) { GetAngularVelocity_ request; GetAngularVelocityResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_ANGULAR_VELOCITY, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_x = leconvert_int16_from(response.x); *ret_y = leconvert_int16_from(response.y); *ret_z = leconvert_int16_from(response.z); return ret; }
int imu_get_all_data(IMU *imu, int16_t *ret_acc_x, int16_t *ret_acc_y, int16_t *ret_acc_z, int16_t *ret_mag_x, int16_t *ret_mag_y, int16_t *ret_mag_z, int16_t *ret_ang_x, int16_t *ret_ang_y, int16_t *ret_ang_z, int16_t *ret_temperature) { GetAllData_ request; GetAllDataResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_ALL_DATA, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_acc_x = leconvert_int16_from(response.acc_x); *ret_acc_y = leconvert_int16_from(response.acc_y); *ret_acc_z = leconvert_int16_from(response.acc_z); *ret_mag_x = leconvert_int16_from(response.mag_x); *ret_mag_y = leconvert_int16_from(response.mag_y); *ret_mag_z = leconvert_int16_from(response.mag_z); *ret_ang_x = leconvert_int16_from(response.ang_x); *ret_ang_y = leconvert_int16_from(response.ang_y); *ret_ang_z = leconvert_int16_from(response.ang_z); *ret_temperature = leconvert_int16_from(response.temperature); return ret; }
int imu_get_acceleration(IMU *imu, int16_t *ret_x, int16_t *ret_y, int16_t *ret_z) { GetAcceleration_ request; GetAccelerationResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_ACCELERATION, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_x = leconvert_int16_from(response.x); *ret_y = leconvert_int16_from(response.y); *ret_z = leconvert_int16_from(response.z); return ret; }
int imu_get_magnetic_field(IMU *imu, int16_t *ret_x, int16_t *ret_y, int16_t *ret_z) { GetMagneticField_ request; GetMagneticFieldResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_MAGNETIC_FIELD, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_x = leconvert_int16_from(response.x); *ret_y = leconvert_int16_from(response.y); *ret_z = leconvert_int16_from(response.z); return ret; }
int imu_get_protocol1_bricklet_name(IMU *imu, char port, uint8_t *ret_protocol_version, uint8_t ret_firmware_version[3], char ret_name[40]) { GetProtocol1BrickletName_ request; GetProtocol1BrickletNameResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_PROTOCOL1_BRICKLET_NAME, imu->ipcon, imu); if (ret < 0) { return ret; } request.port = port; ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_protocol_version = response.protocol_version; memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); strncpy(ret_name, response.name, 40); return ret; }
int io4_get_edge_count_config(IO4 *io4, uint8_t pin, uint8_t *ret_edge_type, uint8_t *ret_debounce) { DevicePrivate *device_p = io4->p; GetEdgeCountConfig_ request; GetEdgeCountConfigResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IO4_FUNCTION_GET_EDGE_COUNT_CONFIG, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.pin = pin; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_edge_type = response.edge_type; *ret_debounce = response.debounce; return ret; }
int io4_get_edge_count(IO4 *io4, uint8_t pin, bool reset_counter, uint32_t *ret_count) { DevicePrivate *device_p = io4->p; GetEdgeCount_ request; GetEdgeCountResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IO4_FUNCTION_GET_EDGE_COUNT, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.pin = pin; request.reset_counter = reset_counter; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_count = leconvert_uint32_from(response.count); return ret; }
int industrial_digital_in_4_get_edge_count(IndustrialDigitalIn4 *industrial_digital_in_4, uint8_t pin, bool reset_counter, uint32_t *ret_count) { DevicePrivate *device_p = industrial_digital_in_4->p; GetEdgeCount_ request; GetEdgeCountResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_DIGITAL_IN_4_FUNCTION_GET_EDGE_COUNT, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.pin = pin; request.reset_counter = reset_counter; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_count = leconvert_uint32_from(response.count); return ret; }
int imu_get_orientation(IMU *imu, int16_t *ret_roll, int16_t *ret_pitch, int16_t *ret_yaw) { GetOrientation_ request; GetOrientationResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_ORIENTATION, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_roll = leconvert_int16_from(response.roll); *ret_pitch = leconvert_int16_from(response.pitch); *ret_yaw = leconvert_int16_from(response.yaw); return ret; }
int industrial_digital_in_4_get_edge_count_config(IndustrialDigitalIn4 *industrial_digital_in_4, uint8_t pin, uint8_t *ret_edge_type, uint8_t *ret_debounce) { DevicePrivate *device_p = industrial_digital_in_4->p; GetEdgeCountConfig_ request; GetEdgeCountConfigResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_DIGITAL_IN_4_FUNCTION_GET_EDGE_COUNT_CONFIG, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.pin = pin; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_edge_type = response.edge_type; *ret_debounce = response.debounce; return ret; }
int imu_get_quaternion(IMU *imu, float *ret_x, float *ret_y, float *ret_z, float *ret_w) { GetQuaternion_ request; GetQuaternionResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_QUATERNION, imu->ipcon, imu); if (ret < 0) { return ret; } ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_x = leconvert_float_from(response.x); *ret_y = leconvert_float_from(response.y); *ret_z = leconvert_float_from(response.z); *ret_w = leconvert_float_from(response.w); return ret; }
int humidity_v2_get_temperature_callback_configuration(HumidityV2 *humidity_v2, uint32_t *ret_period, bool *ret_value_has_to_change, char *ret_option, int16_t *ret_min, int16_t *ret_max) { DevicePrivate *device_p = humidity_v2->p; GetTemperatureCallbackConfiguration_Request request; GetTemperatureCallbackConfiguration_Response response; int ret; ret = packet_header_create(&request.header, sizeof(request), HUMIDITY_V2_FUNCTION_GET_TEMPERATURE_CALLBACK_CONFIGURATION, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_period = leconvert_uint32_from(response.period); *ret_value_has_to_change = response.value_has_to_change != 0; *ret_option = response.option; *ret_min = leconvert_int16_from(response.min); *ret_max = leconvert_int16_from(response.max); return ret; }
int imu_get_calibration(IMU *imu, uint8_t typ, int16_t ret_data[10]) { GetCalibration_ request; GetCalibrationResponse_ response; int ret; int i; ret = packet_header_create(&request.header, sizeof(request), IMU_FUNCTION_GET_CALIBRATION, imu->ipcon, imu); if (ret < 0) { return ret; } request.typ = typ; ret = device_send_request(imu, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } for (i = 0; i < 10; i++) ret_data[i] = leconvert_int16_from(response.data[i]); return ret; }
int solid_state_relay_get_identity(SolidStateRelay *solid_state_relay, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) { DevicePrivate *device_p = solid_state_relay->p; GetIdentity_Request request; GetIdentity_Response response; int ret; ret = packet_header_create(&request.header, sizeof(request), SOLID_STATE_RELAY_FUNCTION_GET_IDENTITY, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } memcpy(ret_uid, response.uid, 8); memcpy(ret_connected_uid, response.connected_uid, 8); *ret_position = response.position; memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t)); memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); *ret_device_identifier = leconvert_uint16_from(response.device_identifier); return ret; }
int distance_ir_get_analog_value_callback_threshold(DistanceIR *distance_ir, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) { GetAnalogValueCallbackThreshold_ request; GetAnalogValueCallbackThresholdResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), DISTANCE_IR_FUNCTION_GET_ANALOG_VALUE_CALLBACK_THRESHOLD, distance_ir->ipcon, distance_ir); if (ret < 0) { return ret; } ret = device_send_request(distance_ir, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_option = response.option; *ret_min = leconvert_uint16_from(response.min); *ret_max = leconvert_uint16_from(response.max); return ret; }
int servo_get_identity(Servo *servo, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) { DevicePrivate *device_p = servo->p; GetIdentity_ request; GetIdentityResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_IDENTITY, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } strncpy(ret_uid, response.uid, 8); strncpy(ret_connected_uid, response.connected_uid, 8); *ret_position = response.position; memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t)); memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); *ret_device_identifier = leconvert_uint16_from(response.device_identifier); return ret; }
int distance_ir_get_identity(DistanceIR *distance_ir, char ret_uid[8], char ret_connected_uid[8], char *ret_position, uint8_t ret_hardware_version[3], uint8_t ret_firmware_version[3], uint16_t *ret_device_identifier) { GetIdentity_ request; GetIdentityResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), DISTANCE_IR_FUNCTION_GET_IDENTITY, distance_ir->ipcon, distance_ir); if (ret < 0) { return ret; } ret = device_send_request(distance_ir, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } strncpy(ret_uid, response.uid, 8); strncpy(ret_connected_uid, response.connected_uid, 8); *ret_position = response.position; memcpy(ret_hardware_version, response.hardware_version, 3 * sizeof(uint8_t)); memcpy(ret_firmware_version, response.firmware_version, 3 * sizeof(uint8_t)); *ret_device_identifier = leconvert_uint16_from(response.device_identifier); return ret; }
int servo_get_current_position(Servo *servo, uint8_t servo_num, int16_t *ret_position) { DevicePrivate *device_p = servo->p; GetCurrentPosition_ request; GetCurrentPositionResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_CURRENT_POSITION, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_position = leconvert_int16_from(response.position); return ret; }
int sound_intensity_get_intensity_callback_threshold(SoundIntensity *sound_intensity, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) { DevicePrivate *device_p = sound_intensity->p; GetIntensityCallbackThreshold_ request; GetIntensityCallbackThresholdResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SOUND_INTENSITY_FUNCTION_GET_INTENSITY_CALLBACK_THRESHOLD, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_option = response.option; *ret_min = leconvert_uint16_from(response.min); *ret_max = leconvert_uint16_from(response.max); return ret; }
int servo_get_acceleration(Servo *servo, uint8_t servo_num, uint16_t *ret_acceleration) { DevicePrivate *device_p = servo->p; GetAcceleration_ request; GetAccelerationResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_ACCELERATION, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_acceleration = leconvert_uint16_from(response.acceleration); return ret; }
int current12_get_analog_value_callback_threshold(Current12 *current12, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) { DevicePrivate *device_p = current12->p; GetAnalogValueCallbackThreshold_ request; GetAnalogValueCallbackThresholdResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), CURRENT12_FUNCTION_GET_ANALOG_VALUE_CALLBACK_THRESHOLD, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_option = response.option; *ret_min = leconvert_uint16_from(response.min); *ret_max = leconvert_uint16_from(response.max); return ret; }
int servo_get_degree(Servo *servo, uint8_t servo_num, int16_t *ret_min, int16_t *ret_max) { DevicePrivate *device_p = servo->p; GetDegree_ request; GetDegreeResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_DEGREE, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } request.servo_num = servo_num; ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_min = leconvert_int16_from(response.min); *ret_max = leconvert_int16_from(response.max); return ret; }
int io4_get_configuration(IO4 *io4, uint8_t *ret_direction_mask, uint8_t *ret_value_mask) { DevicePrivate *device_p = io4->p; GetConfiguration_ request; GetConfigurationResponse_ response; int ret; ret = packet_header_create(&request.header, sizeof(request), IO4_FUNCTION_GET_CONFIGURATION, device_p->ipcon_p, device_p); if (ret < 0) { return ret; } ret = device_send_request(device_p, (Packet *)&request, (Packet *)&response); if (ret < 0) { return ret; } *ret_direction_mask = response.direction_mask; *ret_value_mask = response.value_mask; return ret; }