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); }