int rotary_poti_get_analog_value_callback_threshold(RotaryPoti *rotary_poti, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) {
DevicePrivate *device_p = rotary_poti->p;
GetAnalogValueCallbackThreshold_ request;
GetAnalogValueCallbackThresholdResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), ROTARY_POTI_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 co2_get_co2_concentration_callback_threshold(CO2 *co2, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) {
DevicePrivate *device_p = co2->p;
GetCO2ConcentrationCallbackThreshold_ request;
GetCO2ConcentrationCallbackThresholdResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), CO2_FUNCTION_GET_CO2_CONCENTRATION_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 gps_get_coordinates(GPS *gps, uint32_t *ret_latitude, char *ret_ns, uint32_t *ret_longitude, char *ret_ew, uint16_t *ret_pdop, uint16_t *ret_hdop, uint16_t *ret_vdop, uint16_t *ret_epe) {
DevicePrivate *device_p = gps->p;
GetCoordinates_ request;
GetCoordinatesResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), GPS_FUNCTION_GET_COORDINATES, 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_latitude = leconvert_uint32_from(response.latitude);
*ret_ns = response.ns;
*ret_longitude = leconvert_uint32_from(response.longitude);
*ret_ew = response.ew;
*ret_pdop = leconvert_uint16_from(response.pdop);
*ret_hdop = leconvert_uint16_from(response.hdop);
*ret_vdop = leconvert_uint16_from(response.vdop);
*ret_epe = leconvert_uint16_from(response.epe);
return ret;
}
int joystick_get_analog_value_callback_threshold(Joystick *joystick, char *ret_option, uint16_t *ret_min_x, uint16_t *ret_max_x, uint16_t *ret_min_y, uint16_t *ret_max_y) {
DevicePrivate *device_p = joystick->p;
GetAnalogValueCallbackThreshold_ request;
GetAnalogValueCallbackThresholdResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), JOYSTICK_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_x = leconvert_uint16_from(response.min_x);
*ret_max_x = leconvert_uint16_from(response.max_x);
*ret_min_y = leconvert_uint16_from(response.min_y);
*ret_max_y = leconvert_uint16_from(response.max_y);
return ret;
}
int joystick_get_analog_value(Joystick *joystick, uint16_t *ret_x, uint16_t *ret_y) {
DevicePrivate *device_p = joystick->p;
GetAnalogValue_ request;
GetAnalogValueResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), JOYSTICK_FUNCTION_GET_ANALOG_VALUE, 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_x = leconvert_uint16_from(response.x);
*ret_y = leconvert_uint16_from(response.y);
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_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 humidity_v2_get_humidity_callback_configuration(HumidityV2 *humidity_v2, uint32_t *ret_period, bool *ret_value_has_to_change, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) {
DevicePrivate *device_p = humidity_v2->p;
GetHumidityCallbackConfiguration_Request request;
GetHumidityCallbackConfiguration_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), HUMIDITY_V2_FUNCTION_GET_HUMIDITY_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_uint16_from(response.min);
*ret_max = leconvert_uint16_from(response.max);
return ret;
}
int moisture_get_moisture_callback_threshold(Moisture *moisture, char *ret_option, uint16_t *ret_min, uint16_t *ret_max) {
DevicePrivate *device_p = moisture->p;
GetMoistureCallbackThreshold_ request;
GetMoistureCallbackThresholdResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), MOISTURE_FUNCTION_GET_MOISTURE_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 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;
}
static void industrial_quad_relay_callback_wrapper_monoflop_done(IndustrialQuadRelay *industrial_quad_relay, Packet *packet) {
MonoflopDoneCallbackFunction callback_function = (MonoflopDoneCallbackFunction)industrial_quad_relay->registered_callbacks[INDUSTRIAL_QUAD_RELAY_CALLBACK_MONOFLOP_DONE];
void *user_data = industrial_quad_relay->registered_callback_user_data[INDUSTRIAL_QUAD_RELAY_CALLBACK_MONOFLOP_DONE];
MonoflopDoneCallback_ *callback = (MonoflopDoneCallback_ *)packet;
callback->selection_mask = leconvert_uint16_from(callback->selection_mask);
callback->value_mask = leconvert_uint16_from(callback->value_mask);
if (callback_function != NULL) {
callback_function(callback->selection_mask, callback->value_mask, user_data);
}
}
static void industrial_digital_in_4_callback_wrapper_interrupt(DevicePrivate *device_p, Packet *packet) {
InterruptCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT];
InterruptCallback_ *callback = (InterruptCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[INDUSTRIAL_DIGITAL_IN_4_CALLBACK_INTERRUPT];
if (callback_function == NULL) {
return;
}
callback->interrupt_mask = leconvert_uint16_from(callback->interrupt_mask);
callback->value_mask = leconvert_uint16_from(callback->value_mask);
callback_function(callback->interrupt_mask, callback->value_mask, user_data);
}
static void joystick_callback_wrapper_analog_value_reached(DevicePrivate *device_p, Packet *packet) {
AnalogValueReachedCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[JOYSTICK_CALLBACK_ANALOG_VALUE_REACHED];
AnalogValueReachedCallback_ *callback = (AnalogValueReachedCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[JOYSTICK_CALLBACK_ANALOG_VALUE_REACHED];
if (callback_function == NULL) {
return;
}
callback->x = leconvert_uint16_from(callback->x);
callback->y = leconvert_uint16_from(callback->y);
callback_function(callback->x, callback->y, user_data);
}
int sound_intensity_get_identity(SoundIntensity *sound_intensity, 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 = sound_intensity->p;
GetIdentity_ request;
GetIdentityResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), SOUND_INTENSITY_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 industrial_quad_relay_get_identity(IndustrialQuadRelay *industrial_quad_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 = industrial_quad_relay->p;
GetIdentity_Request request;
GetIdentity_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_QUAD_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 multi_touch_get_identity(MultiTouch *multi_touch, 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 = multi_touch->p;
GetIdentity_ request;
GetIdentityResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), MULTI_TOUCH_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;
}
static void industrial_quad_relay_callback_wrapper_monoflop_done(DevicePrivate *device_p, Packet *packet) {
MonoflopDone_CallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[DEVICE_NUM_FUNCTION_IDS + INDUSTRIAL_QUAD_RELAY_CALLBACK_MONOFLOP_DONE];
MonoflopDone_Callback *callback = (MonoflopDone_Callback *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[DEVICE_NUM_FUNCTION_IDS + INDUSTRIAL_QUAD_RELAY_CALLBACK_MONOFLOP_DONE];
if (callback_function == NULL) {
return;
}
callback->selection_mask = leconvert_uint16_from(callback->selection_mask);
callback->value_mask = leconvert_uint16_from(callback->value_mask);
callback_function(callback->selection_mask, callback->value_mask, user_data);
}
int industrial_quad_relay_get_monoflop(IndustrialQuadRelay *industrial_quad_relay, uint8_t pin, uint16_t *ret_value, uint32_t *ret_time, uint32_t *ret_time_remaining) {
DevicePrivate *device_p = industrial_quad_relay->p;
GetMonoflop_Request request;
GetMonoflop_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), INDUSTRIAL_QUAD_RELAY_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 = leconvert_uint16_from(response.value);
*ret_time = leconvert_uint32_from(response.time);
*ret_time_remaining = leconvert_uint32_from(response.time_remaining);
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 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_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 servo_get_period(Servo *servo, uint8_t servo_num, uint16_t *ret_period) {
DevicePrivate *device_p = servo->p;
GetPeriod_ request;
GetPeriodResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_PERIOD, 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_period = leconvert_uint16_from(response.period);
return ret;
}
int servo_get_servo_current(Servo *servo, uint8_t servo_num, uint16_t *ret_current) {
DevicePrivate *device_p = servo->p;
GetServoCurrent_ request;
GetServoCurrentResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), SERVO_FUNCTION_GET_SERVO_CURRENT, 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_current = leconvert_uint16_from(response.current);
return ret;
}
int segment_display_4x7_get_identity(SegmentDisplay4x7 *segment_display_4x7, 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 = segment_display_4x7->p;
GetIdentity_ request;
GetIdentityResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), SEGMENT_DISPLAY_4X7_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_us_get_identity(DistanceUS *distance_us, 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 = distance_us->p;
GetIdentity_Request request;
GetIdentity_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), DISTANCE_US_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 ambient_light_v2_get_identity(AmbientLightV2 *ambient_light_v2, 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 = ambient_light_v2->p;
GetIdentity_ request;
GetIdentityResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), AMBIENT_LIGHT_V2_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 temperature_ir_get_identity(TemperatureIR *temperature_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) {
DevicePrivate *device_p = temperature_ir->p;
GetIdentity_ request;
GetIdentityResponse_ response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), TEMPERATURE_IR_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 piezo_buzzer_get_identity(PiezoBuzzer *piezo_buzzer, 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), PIEZO_BUZZER_FUNCTION_GET_IDENTITY, piezo_buzzer->ipcon, piezo_buzzer);
if (ret < 0) {
return ret;
}
ret = device_send_request(piezo_buzzer, (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 motion_detector_v2_get_identity(MotionDetectorV2 *motion_detector_v2, 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 = motion_detector_v2->p;
GetIdentity_Request request;
GetIdentity_Response response;
int ret;
ret = packet_header_create(&request.header, sizeof(request), MOTION_DETECTOR_V2_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;
}
static void gps_callback_wrapper_coordinates(DevicePrivate *device_p, Packet *packet) {
CoordinatesCallbackFunction callback_function;
void *user_data = device_p->registered_callback_user_data[GPS_CALLBACK_COORDINATES];
CoordinatesCallback_ *callback = (CoordinatesCallback_ *)packet;
*(void **)(&callback_function) = device_p->registered_callbacks[GPS_CALLBACK_COORDINATES];
if (callback_function == NULL) {
return;
}
callback->latitude = leconvert_uint32_from(callback->latitude);
callback->longitude = leconvert_uint32_from(callback->longitude);
callback->pdop = leconvert_uint16_from(callback->pdop);
callback->hdop = leconvert_uint16_from(callback->hdop);
callback->vdop = leconvert_uint16_from(callback->vdop);
callback->epe = leconvert_uint16_from(callback->epe);
callback_function(callback->latitude, callback->ns, callback->longitude, callback->ew, callback->pdop, callback->hdop, callback->vdop, callback->epe, user_data);
}
